keyBuf[keyBufWrPt++]=rURXH1;//rx buffer->keyBuf[]
	if(keyBufWrPt==KEY_BUFLEN)
	    keyBufWrPt=1;
    }
}


void __irq Uart1_RxFifoErrorInt(void)
{
    rI_ISPC=BIT_UERR01;

    switch(rUERSTAT1)//to clear and check the status of register bits
    {
	case '1':
	    Uart_Printf("Overrun error\n");
	    break;
	case '2':
	    Uart_Printf("Parity error\n");
	    break;
	case '4':
	    Uart_Printf("Frame error\n");
	    break;
	case '8':
	    Uart_Printf("Breake detect\n");
	    break;
	default :
	    break;
    }
    while( (rUFSTAT1&0xf) >0 )
    {
	keyBuf[keyBufWrPt++]=rURXH1;
	if(keyBufWrPt==KEY_BUFLEN)
	    keyBufWrPt=0;
    }
}


void Test_Uart1(void)
{
    int key;
    Uart_Port(); 
    keyBufRdPt=keyBufWrPt=0;
    pISR_UTXD1=(unsigned)Uart1_TxInt;
    pISR_URXD1=(unsigned)Uart1_RxInt;
   
    /*********** UART1 Tx test with interrupt ***********/  
    Uart_Printf("[Uart channel 1 tx Interrupt Test]\n");
    Uart_Printf("Plug the serial cable into ch1 connector!!! \n");
    Uart_Printf("Then, press any key through UART ch1.\n");
    Uart_Select(1);
    Uart_Getch();

    uart1TxStr="UART1 Tx interrupt test is good!!!!\r\n";
    rINTMSK=~(BIT_GLOBAL|BIT_UTXD1);
//  rUCON1 &= 0x3f3;   
//  rUCON1 |= 0x4;  //needed to set the UTXD0 pending bit.
    rUCON1 = 0x244; //rx:edge,tx:level,error int,normal*2,interrupt(Start)
    Delay(3000);

    /*********** UART1 Tx test with BDMA1 ***********/
    rUCON1 = 0x245;

    Uart_Printf("\n[Uart1 Tx Test by BDMA1]\n");
    uart1TxStr="UART1 Tx Test by BDMA1 is good!!!!\r\n";
    Uart_TxEmpty(1);

    rUCON1=0x4c;    //tx:BDMA0 rx:disable

    rBDICNT1=0x0;
    rBDCON1 =0x0;
    rBDISRC1=(unsigned int)uart1TxStr|(0<<30)|(1<<28);  // byte,inc
    rBDIDES1=UTXH1 |(1<<30)|(3<<28);  //L/B endian,M2IO,fix   
    rBDICNT1=strlen((char *)uart1TxStr)|(2<<30)|(1<<26)|(0<<20); //UART1,
    rBDICNT1 |= (1<<20); //enable

    while(!((rBDCON1&0x30)==0x20));
    Uart_TxEmpty(1);

    /*********** UART1 Rx test with interrupt ***********/
    rUCON1=0x45;    //tx:int rx:int
    Uart_Printf("\n[Uart channel 1 Rx Interrupt Test]:Type any key!!!\n");
    Uart_Printf("You have to see the typed character. To quit, press Enter key.\n");

    rINTMSK=~(BIT_GLOBAL|BIT_URXD1);

    keyBufRdPt=keyBufWrPt=0;    
    while((key=Uart_IntGetkey())!='\r')
        Uart_SendByte(key);

    rINTMSK=~BIT_GLOBAL;
    Uart_Printf("\n");

    Uart_Printf("Plug the serial cable into ch0 as before this test!!!\n");
    Uart_Printf("Then, press any key through UART ch 0.\n");
    Uart_Select(0);
    Uart_Getch();
    Return_Port();
}


void __irq Uart1_RxInt(void)
{
    rI_ISPC=BIT_URXD1;

    keyBuf[keyBufWrPt++]=RdURXH1();
    if(keyBufWrPt==KEY_BUFLEN)
	keyBufWrPt=0;
}


void __irq Uart1_TxInt(void)
{
//    rI_ISPC=BIT_UTXD1;

    if(*uart1TxStr != '\0')
    {
	WrUTXH1(*uart1TxStr++);
	rI_ISPC=BIT_UTXD1;
    }
    else
/*    {
	rUCON1 &= 0x3f3;//workaround for ES1, ES2
	rI_ISPC=BIT_UTXD1;
	rINTMSK|=BIT_UTXD1;
    }*/
    {				//ES3
	rINTMSK |= BIT_UTXD1;	//ES3
	rI_ISPC=BIT_UTXD1;	//ES3
    }				//ES3
}

////////Auto Flow Control TEST(Tx)////////////////

volatile unsigned char * volatile tx0,* tx1,*tx2,tx_end=0;
volatile int i;
volatile int tx_cnt=0;
void Test_UartAFC_Tx(void)
{
    Uart_Port();
    tx_cnt=0;

    tx0=(unsigned char *)malloc(AFC_BUFLEN);
    tx1=tx0;
    tx2=tx0;
    Uart_Printf("!!!tx0=0x%x\n",tx0);

    for(i=0;i<AFC_BUFLEN;i++)
	*tx1++=i;

    pISR_UTXD1=(unsigned)U1AFC_TxInt;

//    Led_Display(0xf);	//LED off
    
    Uart_Printf("[UART AFC Tx Test]\n");
    Uart_Printf("This test should be configured two boards.\n");
    Uart_Printf("Connect twitsted(rx/tx, nCTS/nRTS) cable com2 to other board's com1 port.\n");
    Uart_Printf("Start Rx first and press any key and,.\n");
    Uart_TxEmpty(0);
    Uart_Getch();

    rUCON1=(1<<9)|(0<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
    rUFCON1=0x0;    //FIFO disable
    rUMCON1=0x10;   //Uart1 AFC enable

    Uart_Printf("Now... Tx with AFC\n");
    Uart_TxEmpty(0);
    rINTMSK=~(BIT_GLOBAL|BIT_UTXD1);

    while(!tx_end);

    Led_Display(0x0);	//LED on
    Uart_Printf("\nEnd Tx, transfer data count=%d\n",tx_cnt);

    Return_Port();
    free((void *)tx0);
    tx_end=0;
    tx_cnt=0;
}

void __irq U1AFC_TxInt(void)
{
    if(tx_cnt < (AFC_BUFLEN))
    {
	Uart_Printf("%d,",*tx2);
	WrUTXH1(*tx2++);
	rI_ISPC=BIT_UTXD1;
	tx_cnt++;
    }
    else
    {
	Uart_TxEmpty(1);
/*	rUCON1 &= 0x3f3;//workaround for ES1,2
	rI_ISPC=BIT_UTXD1;
	rINTMSK|=BIT_UTXD1;*/
	rINTMSK |= BIT_UTXD0;	//ES3
	rI_ISPC=BIT_UTXD0;	//ES3
	tx_end=1;
    }
}


////////Auto Flow Control TEST(Rx with FIFO)////////////////

volatile unsigned char *rx0,*rx1,*rx2,rx_end=0;
volatile int rx_cnt=0;

void Test_UartAFC_Rx(void)
{
    unsigned int i;
    unsigned int err_cnt=0;

    Uart_Port();

    Uart_Printf("[UART AFC Rx Test]\n");
    Uart_Printf("This test should be configured two boards.\n");
    Uart_Printf("Connect twisted(rx/tx, nCTS/nRTS) cable com1 to other board's com2 port.\n");
    Uart_Printf("Then, change connected cable between host and com1, host to com2.\n");
    Uart_Printf("Press any key to com2 and start Rx first.\n");
    Uart_TxEmpty(0);

    Uart_Select(1);
    Uart_Getch();
    
    rx0=(unsigned char *)malloc(AFC_BUFLEN);
    rx1=rx0;
    rx2=rx0;

    pISR_URXD0=(unsigned)U0AFC_RxInt;
    pISR_UERR01=(unsigned)U0AFC_RxErrorInt;

    Led_Display(0xf);	//LED off
    

    rUMCON0=0x10;   //Uart0 AFC enable
    rUCON0=(1<<9)|(0<<8)|(1<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
    rUFCON0=(2<<6)|(1<<4)|(1<<2)|(1<<1)|(1);


    Uart_Printf("Now... Rx with AFC\n");
    Uart_TxEmpty(1);

    rINTMSK=~(BIT_GLOBAL|BIT_URXD0|BIT_UERR01);

    while(!rx_end);
    Delay(1000);

    rINTMSK=BIT_GLOBAL;

    Uart_Printf("\nEnd Rx, receive data count=%d\n",rx_cnt);
    Led_Display(0x0);	//LED on
    Uart_Printf("Now, change connected cable between host and com2, host to com1.\n");
    Uart_Printf("Then, press any key.\n");
    Uart_Init(0,115200);
    Uart_Select(0);
    Uart_Getch();

    for(i=0;i<AFC_BUFLEN;i++)
    {
	if(i-(*rx1++))
	{
	    Uart_Printf("i=%d\n",i);
	    err_cnt++;
	}
    }
    if(err_cnt)
	Uart_Printf("AFC test fail!! Error count=%d\n",err_cnt);
    else
	Uart_Printf("AFC test is good!!\n");

    Return_Port();
    free((void *)rx0);
    rx_end=0;
    rx_cnt=0;
}


void __irq U0AFC_RxInt(void)
{
    rI_ISPC=BIT_URXD0;

    while( (rUFSTAT0 & 0x100) || ((rUFSTAT0 & 0xf) >0) )
    {
	Delay(1000);
	*rx2++=rURXH0;
	Uart_Printf("%d,",*(rx2-1));
	rx_cnt++;
    }
    if(rx_cnt == (AFC_BUFLEN))
        rx_end=1;
}


void __irq U0AFC_RxErrorInt(void)
{
    rI_ISPC=BIT_UERR01;

    switch(rUERSTAT0)//to clear and check the status of register bits
    {
	case 1:
	    WrUTXH1('!');
	    break;
	case 2:
	    WrUTXH1('#');
	    break;
	case 4:
	    WrUTXH1('$');
	    break;
	case 8:
	    WrUTXH1('@');
	    break;
	default :
	    WrUTXH1('*');
	    break;
    }
}


char _done=0, error=0;
void Test_BDMA(void)
{
    char *_buf,i;
    char *_temp2;
    int *_temp;

    _buf=(char *)malloc(100);
    _temp=(int *)malloc(1);
    _temp2=_buf;


    rINTMSK=~(BIT_GLOBAL|BIT_BDMA0|BIT_UERR01);
    pISR_BDMA0=(unsigned)Test_Done;
    pISR_UERR01=(unsigned)Error;
    Uart_Init(0,115200);    
    Uart_Printf("[Read BDCON0 register in Rxing...]\n");
    Uart_TxEmpty(0);

    rBDISRC0=(0<<30)+(3<<28)+(int)URXH0;    //byte,inc,Rx-buf
    rBDIDES0=(2<<30)+(1<<28)+(int)_buf;	    //M2IO,fix,IISFIF
    rBDICNT0=(2<<30)+(1<<26)+(3<<22)+(1<<21)+(0<<20)+700;
    //Uart0,reserve,done_int,auto-reload/start,DMA disable,COUNT
    rBDICNT0 |= (1<<20);//enable
    rBDCON0 = 0x0<<2;

    rUCON0=0x2c6;	//tx:polling rx:BDMA0    

    while(!_done)
    {
	*_temp=rBDCON0;
	if((rBDCON0 & 0xf))
	{
	    Uart_Printf("!!Error0x%x!!,",rBDCON0);
	    break;
	}
    }
    Uart_Printf("!END!\n");

    if(error)
	Uart_Printf("[rUERSTAT=0x%x]\n",rUERSTAT0);

    rINTMSK=BIT_GLOBAL;
//    rUCON0 &= 0x3fd;//Rx disable
    rBDICNT0=0x0;   //BDMA stop

    for(i=0;i<10;i++)
	Uart_Printf("%d=0x%x,",i,*_temp2++);
    Uart_Printf("\n0x%x,",*_temp);

    free(_buf);
    _done=0;
}

void __irq Test_Done(void)
{
    rI_ISPC=BIT_BDMA0;	//clear pending bit
    _done=1;
}

void __irq Error(void)
{
    rI_ISPC=BIT_UERR01;
    error=1;
}