uart.c

2440超级bios（ads1.2 rvds2.2）通用

/*
*******************************************************************************
* file name:	rtc.c
* description:	rtc driver
* author:		xzChen([e-mail])
* QQ / msn:		36725175 / [e-mail]
*******************************************************************************
*/
#ifndef __UART_C__
#define __UART_C__

#include "..\\Includes.h"

#define WRITE_UART      WrUTXH1
#define UART_STATUS     rUTRSTAT1

//===================================================================
void UartTxEmpty(U08 uart)
{
	switch (uart)
	{
		case 0:
	        while(!(rUTRSTAT0 & 0x4)); //Wait until tx shifter is empty.
		break;
		case 1:
	        while(!(rUTRSTAT1 & 0x4)); //Wait until tx shifter is empty.
		break;
		case 2:
	        while(!(rUTRSTAT2 & 0x4)); //Wait until tx shifter is empty.
		break;
		default:
		break;
	}
}
void Uart_init(U08 uart,U32 bps)
{
	switch (uart)
	{
		case 0:
		    rUFCON0 = 0x0;      // FIFO disable
		    rUMCON0 = 0x0;      // AFC disable
		    rULCON0 = 0x3;      // Normal,No parity,1 stop,8 bits
		    rUCON0  = 0x245;
		    rUBRDIV0 = ( (int)(PCLK/16./bps+0.5) - 1 );
			UartTxEmpty(0);
			qUart0_R_len = 0;
		break;
		case 1:
		    rUFCON1 = 0x0;      // FIFO disable
		    rUMCON1 = 0x0;      // AFC disable
		    rULCON1 = 0x3;      // Normal,No parity,1 stop,8 bits
		    rUCON1  = 0x245;
		    rUBRDIV1 = ( (int)(PCLK/16./bps+0.5) - 1 );
			UartTxEmpty(1);
			qUart1_R_len = 0;
		break;
		case 2:
		    rUFCON2 = 0x0;      // FIFO disable
		    rUMCON2 = 0x0;      // AFC disable
		    rULCON2 = 0x3;      // Normal,No parity,1 stop,8 bits
		    rUCON2  = 0x245;
		    rUBRDIV2 = ( (int)(PCLK/16./bps+0.5) - 1 );
			UartTxEmpty(2);
			qUart2_R_len = 0;
		break;
		default:
		break;
	}
    Delay(100);
}
void UartPutByte(U08 uart,int data)
{
	while(!(UART_STATUS & 0x2));   //Wait until THR is empty.
	Delay(10);
	WrUTXH1(data);
}
void Uart_SendDWORD(U08 uart,DWORD d)
{
    UartPutStr(uart,"0x");
    UartPutStr(uart,hex2char((d & 0xf0000000) >> 28));
    UartPutStr(uart,hex2char((d & 0x0f000000) >> 24));
    UartPutStr(uart,hex2char((d & 0x00f00000) >> 20));    
    UartPutStr(uart,hex2char((d & 0x000f0000) >> 16));
    UartPutStr(uart,hex2char((d & 0x0000f000) >> 12));
    UartPutStr(uart,hex2char((d & 0x00000f00) >> 8));
    UartPutStr(uart,hex2char((d & 0x000000f0) >> 4));
    UartPutStr(uart,hex2char((d & 0x0000000f) >> 0));
}
//====================================================================
void UartPutBuf(U08 uart,U08 *pStr,U32 len)
{
	U32 i;

	switch (uart)
	{
		case 0:
		break;
		case 1:
			for (i=0; i<len; i++)
			{
				while(!(UART_STATUS & 0x2));   //Wait until THR is empty.
				Delay(10);
				WrUTXH1(pStr[i]);
			}
		break;
		default:
		break;
	}
}
void UartPutStr(U08 uart,char *pStr)
{
	U32 i;
	
	switch (uart)
	{
		case 0:
			for (i=0; pStr[i]!='\0'; i++)
			{
				while(!(UART_STATUS & 0x2));	// Wait until THR is empty.
				Delay(10);
				WrUTXH0(pStr[i]);
			}
		break;
		case 1:
		    for (i=0; pStr[i]!='\0'; i++)
			{
				while(!(UART_STATUS & 0x2));	// Wait until THR is empty.
				Delay(10);
				WrUTXH1(pStr[i]);
			}
		break;
		case 2:
			for (i=0; pStr[i]!='\0'; i++)
			{
    	    	while(!(rUTRSTAT2 & 0x2));		// Wait until THR is empty.
        		Delay(10);
				WrUTXH2(pStr[i]);
	        }
		break;
		default:
		break;
	}
}
char UartGetByte(U08 uart)
{
    switch (uart)
    {
    	case 0:
	        while(!(rUTRSTAT0 & 0x1)); // Receive data ready
    	    return RdURXH0();
    	break;
    	case 1:
	        while(!(rUTRSTAT1 & 0x1)); // Receive data ready
    	    return RdURXH1();
    	break;
    	case 2:
	        while(!(rUTRSTAT2 & 0x1)); // Receive data ready
    	    return RdURXH2();
    	break;
    	default:
    	break;
    }
}
void UartGetStr(U08 uart,char *string)
{
    char *string2 = string;
    char c;
    while((c = UartGetByte(uart))!='\r')
    {
        if(c=='\b')
        {
            if( (int)string2 < (int)string )
            {
                UartPrintf(uart,"\b \b");
                string--;
            }
        }
        else 
        {
            *string++ = c;
            UartPutByte(uart,c);
        }
    }
    *string='\0';
    UartPutByte(uart,'\n');
}
int Uart_GetIntNum(U08 uart)
{
    char str[30];
    char *string = str;
    int base     = 10;
    int minus    = 0;
    int result   = 0;
    int lastIndex;    
    int i;
    
    UartGetStr(uart,string);
    
    if(string[0]=='-')
    {
        minus = 1;
        string++;
    }
    
    if(string[0]=='0' && (string[1]=='x' || string[1]=='X'))
    {
        base    = 16;
        string += 2;
    }
    
    lastIndex = strlen(string) - 1;
    
    if(lastIndex<0)
        return -1;
    
    if(string[lastIndex]=='h' || string[lastIndex]=='H' )
    {
        base = 16;
        string[lastIndex] = 0;
        lastIndex--;
    }

    if(base==10)
    {
        result = atoi(string);
        result = minus ? (-1*result):result;
    }
    else
    {
        for(i=0;i<=lastIndex;i++)
        {
            if(isalpha(string[i]))
            {
                if(isupper(string[i]))
                    result = (result<<4) + string[i] - 'A' + 10;
                else
                    result = (result<<4) + string[i] - 'a' + 10;
            }
            else
                result = (result<<4) + string[i] - '0';
        }
        result = minus ? (-1*result):result;
    }
    return result;
}
void UartPrintf(U08 uart,char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    UartPutStr(uart,string);
    va_end(ap);
}
void Uart0App(void)
{
	if (bitflags.bits.irq_uart0)
	{
		bitflags.bits.irq_uart0 = 0;
		qUart0_R_len = 0;
	}
}
void Uart1App(void)
{
	U32 i,j,cmdlen,tmplen;
	SHELL_CMD *pShlCmd;
	char cmd[20];
	
	if (ShellActive == SHL_ACTIVE_MAX)	// 625us*16*1000 = 10s
	{
		ShellActive = 0;
		UartPutStr(SHL_PRT,"Shell Runing\r\n");
	}
	UartGetStr(SHL_PRT,cmd);
	UartPutStr(SHL_PRT,"receive command: ");
	UartPutStr(SHL_PRT,cmd);
	UartPutStr(SHL_PRT,"\r\n");
	pShlCmd = shell_sel();
	i = 0;
	while(pShlCmd[i].iCmd != 0)
	{
		cmdlen = strlen(pShlCmd[i].cmd);
		for (j=0; j<cmdlen; j++)
		{
			// 大写转小写
			if ((cmd[j] >= 'A') && (cmd[j] <= 'Z'))
				cmd[j] += 0x20;
			if(cmd[j] != pShlCmd[i].cmd[j])
				break;
		}
		if (j == cmdlen)
		{
			UartPutStr(SHL_PRT,"\r\ncommand OK!!!\r\n");
			if(pShlCmd[i].func != NULL)
			{
				pShlCmd[i].func(0,NULL);
				break;
			}
		}
		i++;
	}
	if (pShlCmd[i].iCmd == 0)
	{
		UartPutStr(SHL_PRT,"\r\ncommend ERROR!!!\r\n");
	}
	/*
	if (bitflags.bits.irq_uart1)
	{
		bitflags.bits.irq_uart1 = 0;
		ShellActive = 0;
		if(qUart1_R_len)
			tmplen = qUart1_R_len - 1;
		else
			tmplen = qUart1_R_len;
		UartPutBuf(SHL_PRT,&(qUart1_R_buf[tmplen]),1);
		// gDispChar(0, 0,qUart1_R_buf.Data[tmplen],0);
		switch (qUart1_R_buf[tmplen])
		{
			case 0x08:	// 退格
				qUart1_R_len--;
			break;
			case '\r':	// 回车
				qUart1_R_len = 0;
				i = 0;
				pShlCmd = shell_sel();
				while(pShlCmd[i].iCmd != 0)
				{
					cmdlen = strlen(pShlCmd[i].cmd);
					for (j=0; j<cmdlen; j++)
					{
						// 大写转小写
						if ((qUart1_R_buf[j] >= 'A') &&
							(qUart1_R_buf[j] <= 'Z'))
							qUart1_R_buf[j] += 0x20;
						if(qUart1_R_buf[j] != pShlCmd[i].cmd[j])
							break;
					}
					if (j == cmdlen)
					{
						if(pShlCmd[i].func != NULL)
							pShlCmd[i].func(0,NULL);
					}
					i++;
				}
			break;
			default:
			break;
		}
	}
	*/
}
void Uart2App(void)
{
	U32 i;
	
	if (bitflags.bits.irq_uart2)
	{
		bitflags.bits.irq_uart2 = 0;
		for (i=0; i<qUart2_R_len; i++)
			gPrintf(0,0,0xffff,0,"%c",qUart2_R_buf);
//		UartPutBuf(SHL_PRT, qUart2_R_buf.Data, qUart2_R_buf.iLen);
		qUart2_R_len = 0;
//		DecodeNema(qUart2_R_buf.Data);
//		UartPutStr(GPS_PRT,"$PSRF104,0,0,0,96000,237759,922,12,4*2E\r\n");
	}
}

#endif