嵌入式MCU 实现串口类似 控制台命令行交互方式

1.头文件user_uart.h

#ifndef USER_UART_H
#define USER_UART_H

#define UART_CNT(head, tail, size) (((head) - (tail)) & ((size)-1))
#define UART_SPACE(head, tail, size) UART_CNT((tail), ((head)+1), (size))

#define UART1_RXBUFF_MAX				(1024*4)			// uart rx buff size

typedef struct _UART1_BUFF_INFO
{		
	char uart_rx[UART1_RXBUFF_MAX];		// uart recive buff
	int wptr;								// uart recive buff write offset
	int rptr;								// uart recive buff  report offset
}UART1_BUFF_INFO;

void UserUartInit(void);
int UserUart1Read(char *buf, int read_len, int wait);
void UserUart1Clear(void);
void UserUart1Info(char *str);

#endif

查看buffer里是否有收到数据

int console_rx_get(void)
{
    return UART_CNT(gsUart0BuffInfo.wptr, gsUart0BuffInfo.rptr, UART0_RXBUFF_MAX);
}

控制台头文件 consloe_cmd.h

#ifndef CONSOLE_CMD_H
#define CONSOLE_CMD_H

#define UART0_RXBUFF_MAX				128			// uart rx buff size

typedef struct _UART0_BUFF_INFO
{		
	char uart_rx[UART0_RXBUFF_MAX];			// uart recive buff
	int wptr;								// uart recive buff write offset
	int rptr;								// uart recive buff  report offset
}UART0_BUFF_INFO;

typedef struct _CONSOLE_CMD
{
	char *cmd;
	int (*callfn)(char *buf);	
	char *info;
	char *example;
}CONSOLE_CMD;

void console_init(void);
INT16S console_uart_rx_callback(char *buf, INT16U len);
int console_rx_get(void);
int console_rx_proc(void);

串口数据转存到buffer中

#include "user_config.h"
#include "user_uart.h"
#include "console_cmd.h"



static int console_oneshot_proc(char *buff);
static int console_fwup_proc(char *buff);
static int console_udisk_proc(char *buff);
static int console_task_proc(char *buff);
static int console_show_help(char *buf);
static int console_key_proc(char *buff);

extern void UserSendMsg(INT32U msg);
extern void disp_task_stat_info(void);
extern void MediaDataStop(void);
extern void UserFwupProc(char * url);

static char CONSOLE_HELP[] = "help";
static CONSOLE_CMD  console_tbl[] =
{
    {"t-oneshot", 	console_oneshot_proc,	"Start oneshot config.",					"# t-oneshot"},
    {"t-fwup", 	console_fwup_proc,		"Http fwup.",							"# t-fwup=[url]"},
    {"t-udisk", 	console_udisk_proc,		"Create spi flash udisk.",				"# t-udisk=[url]"},
    {"t-task",	console_task_proc,		"Show task info.",						"# t-task"},
    {"t-key",		console_key_proc,		"key.",								"# t-key"},
    {"t-dbg",		console_dbg_proc,		"dbg.",								"# t-dbg"},
    //{"t-song",		console_song_proc,		"song.",								"# t-song"},
    //{"wrid",		console_down_id_proc,		"id.",								"#wrid"},
  	//{"t-led",		 console_led_proc,		"led.",								"# t-led"},
    {CONSOLE_HELP, 	console_show_help,	"Help info.",						"# help"}
};
static char *pAudioVer = "V0.1.1";
static UART0_BUFF_INFO gsUart0BuffInfo;
/***************************************************************************
* Description: console_init
****************************************************************************/
void console_init(void)
{
    memset(&gsUart0BuffInfo, 0, sizeof(UART0_BUFF_INFO));
    console_show_help(NULL);
}
/***************************************************************************
* Description:console_uart_rx_callback
****************************************************************************/
INT16S console_uart_rx_callback(char *buf, INT16U len)
{
    int buffsize;
    int wcount;
    int temp;

    //获取串口缓冲区剩余的大小
    buffsize = UART_SPACE(gsUart0BuffInfo.wptr, gsUart0BuffInfo.rptr, UART0_RXBUFF_MAX);
    //设置可以写的数据长度
    if(buffsize >= len)
    {
        wcount = len;
    }
    else
    {
        printf("houxf debug uart over buff  %d, %d\r\n", buffsize, len);
        return -1;
    }
    //填充数据到串口缓冲区
    if(gsUart0BuffInfo.wptr + wcount <= UART0_RXBUFF_MAX)
    {
        memcpy(gsUart0BuffInfo.uart_rx + gsUart0BuffInfo.wptr, buf, wcount);
        gsUart0BuffInfo.wptr += wcount;
    }
    else
    {
        temp = UART0_RXBUFF_MAX - gsUart0BuffInfo.wptr;
        memcpy(gsUart0BuffInfo.uart_rx + gsUart0BuffInfo.wptr, buf, temp);
        memcpy(gsUart0BuffInfo.uart_rx, buf + temp, wcount - temp);
        gsUart0BuffInfo.wptr = wcount - temp;
    }
    return 0;
}
/***************************************************************************
* Description:console_rx_get
****************************************************************************/
int console_rx_get(void)
{
    return UART_CNT(gsUart0BuffInfo.wptr, gsUart0BuffInfo.rptr, UART0_RXBUFF_MAX);
}
/***************************************************************************
* Description:console_rx_proc
*
* Auth: 
*
*Date: 2015-3-31
****************************************************************************/
int console_rx_proc(void)
{
    static int predatalen = 0;
    int datalen, i;

    datalen = UART_CNT(gsUart0BuffInfo.wptr, gsUart0BuffInfo.rptr, UART0_RXBUFF_MAX);
    if(datalen)
    {
        if(predatalen != datalen)
        {
            predatalen = datalen;
        }
        else
        {
            for(i = 0;; i ++)
            {
                if(strstr(gsUart0BuffInfo.uart_rx, console_tbl[i].cmd) != NULL)
                {
                    printf("\r\n# %s\r\n\r\n", gsUart0BuffInfo.uart_rx);
                    if(console_tbl[i].callfn)
                    {
                        console_tbl[i].callfn(gsUart0BuffInfo.uart_rx);
                    }
                    break;
                }
                if(strstr(console_tbl[i].cmd, CONSOLE_HELP) != NULL)	//已经到最后一个
                {
                    break;
                }
            }
            memset(gsUart0BuffInfo.uart_rx, 0, UART0_RXBUFF_MAX);
            gsUart0BuffInfo.wptr =0;
            gsUart0BuffInfo.rptr = 0;
            predatalen = 0;
        }
    }
    return 0;
}
/***************************************************************************
* Description:console_show_help
*
****************************************************************************/
static int console_show_help(char *buf)
{
    int i;

    printf("******************************************************\r\n");
    printf("console command = wm audio %s %s %s\r\n", pAudioVer, __DATE__, __TIME__);
    printf("******************************************************\r\n");
    for(i = 0; ; i ++)
    {
        printf("%d.",i+1);
        printf("%s\r\n", console_tbl[i].info);
        printf("%s\r\n\r\n", console_tbl[i].example);
        if(0 == strcmp(console_tbl[i].cmd, CONSOLE_HELP))
        {
        	  printf("Save id = %s, serial = %s\r\n", login_param.robot_id, login_param.robot_searl);
            break;
        }
    }
    return 0;
}
/***************************************************************************
* Description:console_oneshot_proc
****************************************************************************/
static int console_oneshot_proc(char *buff)
{
    UserSendMsg(MSG_ONESHOT);
    return 0;
}
/***************************************************************************
* Description:console_fwup_proc
*
* Auth: houxf
*
*Date: 2015-3-31
****************************************************************************/
static int console_fwup_proc(char *buff)
{
    char *p = NULL, *p1 = NULL;

    p = strstr(buff, "[");
    p1 = strstr(buff, "]");
    if((NULL == p) || (NULL == p1))
    {
        USER_PRINT("console_fwup_proc url error!\r\n");
        return -1;
    }
    *p1 = 0;
    MediaDataStop();
    UserFwupProc(p + 1);
    return 0;
}
extern void HttpFlashWrite(char * url);
/***************************************************************************
* Description:console_udisk_proc
****************************************************************************/
static int console_udisk_proc(char *buff)
{
    char *p = NULL, *p1 = NULL;

    p = strstr(buff, "[");
    p1 = strstr(buff, "]");
    if((NULL == p) || (NULL == p1))
    {
        USER_PRINT("console_fwup_proc url error!\r\n");
        return -1;
    }
    *p1 = 0;
    MediaDataStop();
    HttpFlashWrite(p + 1);
    return 0;
}
/***************************************************************************
* Description:console_task_proc
****************************************************************************/
static int console_task_proc(char *buff)
{
    disp_task_stat_info();
    return 0;
}
/***************************************************************************
* Description:console_task_proc
*
* Auth: houxf
*
*Date: 2015-3-31
****************************************************************************/
static int console_key_proc(char *buff)
{
    char *p = NULL, *p1 = NULL;

    p = strstr(buff, "[");
    p1 = strstr(buff, "]");
    if((NULL == p) || (NULL == p1))
    {
        USER_PRINT("console_fwup_proc url error!\r\n");
        return -1;
    }
    *p1 = 0;
    if(!strcmp(p + 1, "id"))
    {
        UserSendMsg(MSG_KEY_DOWN | (KEY_ID_RID << 16));
    }
    else if(!strcmp(p + 1, "rstop"))
    {
        UserSendMsg(MSG_KEY_UP | (KEY_ID_REC << 16));
    }
    return 0;
}


int splite(char dst[][20],char* str,const char* spl){
   int n=0;
	 char* result=NULL;
	 result=strtok(str,spl);
   while(result!=NULL){
	   strcpy(dst[n++],result);
		 result=strtok(NULL,spl);
	 }
	 return n;
}

led_param_t getLedParam(char mScene[20],char mAction[20]){
	 led_param_t param;
   led_scene_e scene=0;
	 led_action_e action=0;
	 if(strcmp(mAction,"OPEN")==0){
	    action=SCENE_OPEN;

	 }else{

	    action=SCENE_CLOSE;
	 }
 	 if(strcmp(mScene,"AI")==0){
	    scene=SCENE_AI_MODE;
	
	 }else if(strcmp(mScene,"MUSIC")==0){
//	    scene=SCENE_MUSIC_MODE;//jun
	
	 }else if(strcmp(mScene,"FULL")==0){
	    scene=SCENE_POWER_FULL;
		
	 }else if(strcmp(mScene,"CHARGE")==0){
	    scene=SCENE_POWER_CHARGE;
	
	 }else if(strcmp(mScene,"LOW")==0){
	    scene=SCENE_POWER_LOW;
		 
	 }else if(strcmp(mScene,"IM")==0){
	    scene=SCENE_IM_MSG;

	 }
	 param.mLedSense=scene;
	 param.mLedAct=action;
	 return param;
}



static int console_led_proc(char* buff){
	 char *p = NULL, *p1 = NULL,*pdata=NULL;
    char dst[2][20];
	  led_param_t parm;
    p = strstr(buff, "[");
    p1 = strstr(buff, "]");
    if((NULL == p) || (NULL == p1))
    {
        //USER_PRINT("houxf debug console_fwup_proc url error!\r\n");
        return -1;
    }
    *p1 = '\0';
		splite(dst,p+1,",");
		parm=getLedParam(dst[0],dst[1]);
		mv_AP80_Led_Ctrl((uint8_t)parm.mLedSense,(uint8_t)parm.mLedAct);
//		int cmd=atoi(dst[0]);
//		int action=atoi(dst[1]);
		//printf("cmd=%d,action=%d\n",cmd,action);
    return 0;
}