uart.c

这是ARMSYS44B0-P专业开发板的源代码

/****************************************************************
 *		  ARMSYS S3C44B0X  UART TEST							*  
 ****************************************************************
 
  1.2005.4.23:ZXJ:  UART0 & UART1 TEST
 
 ***************************************************************/
 
#include <string.h>
#include <stdlib.h>
#include "..\target\44b.h"
#include "..\target\44blib.h"
#include "..\target\def.h"
#include "..\uarttest\rtc.h"
#include "..\uarttest\Uart.h"

#define KEY_BUFLEN 100

char Uart_IntGetkey(void);
void Uart_Port(void);
void Return_Port(void);

static unsigned char keyBuf[KEY_BUFLEN];
volatile static int keyBufRdPt=0,keyBufWrPt=0;
volatile static char *uart0TxStr,*uart1TxStr;
volatile char out=1;

volatile U32 save_UC,save_UE,save_UPC,save_UPE;

void Uart_Port(void)
{
    save_UC=rPCONC;		//for RxD1,TxD1  
    save_UE=rPCONE;		//for RxD0,TxD0
    save_UPC=rPUPC;
    save_UPE=rPUPE;
   
    rPCONC |=0x0f000000;			//PC13=RxD1,PC12=TxD1
    rPUPC |=0x3000;					//Uart1 port pull-up disable
    rPCONE=(rPCONE &0x3ffe)|0x28;	//PE2=RxD0,PE1=TxD0
    rPUPE |=0x6;					//Uart0 port pull-up disable 
}


void Return_Port(void)
{
    rPCONC=save_UC;
    rPCONE=save_UE;
    rPUPC=save_UPC;
    rPUPE=save_UPE;
}


char Uart_IntGetkey(void)
{
    if(keyBufRdPt==KEY_BUFLEN)
	keyBufRdPt=0;

    while(keyBufWrPt==keyBufRdPt);  //until FIFO is triggered
    return keyBuf[keyBufRdPt++];
}

////////UART 0 TEST////////////////

void Test_Uart0(void)
{
    int key;
    Uart_Port(); 
    keyBufRdPt=keyBufWrPt=0;
    pISR_UTXD0=(unsigned)Uart0_TxInt;
    pISR_URXD0=(unsigned)Uart0_RxInt;
    
    /*********** UART0 Tx test with interrupt ***********/  
    Uart_Printf("[UART0 Tx 中断测试]\n");
    Uart_TxEmpty(0); //wait until tx shifter is empty.

    uart0TxStr="UART0 Tx 中断测试通过!!!!\r\n";

    rUCON0 = 0x244; //tx:level,rx:edge,error int,normal*2,interrupt(Start)
    rINTMSK=~(BIT_GLOBAL|BIT_UTXD0);

    Delay(3000);

    /*********** UART0 Tx test with BDMA0 ***********/ 
    rUCON0 = 0x245;//for BDMA0

    Uart_Printf("\n[UART0 Tx 在BDMA0方式测试]\n");
    uart0TxStr="UART0 Tx 在BDMA0方式测试通过!!!!\r\n";
    Uart_TxEmpty(0);

    rUCON0=0x48;    //tx:BDMA0 rx:disable

    rBDICNT0=0x0;
    rBDCON0 =0x0;
    rBDISRC0=(unsigned int)uart0TxStr|(0<<30)|(1<<28);  // byte,inc
    rBDIDES0=UTXH0 |(1<<30)|(3<<28);	//L/B endian,M2IO,fix   
    rBDICNT0=strlen((char *)uart0TxStr)|(2<<30)|(1<<26)|(0<<20); //UART0,
    rBDICNT0 |= (1<<20); //enable

    while(!((rBDCON0&0x30)==0x20));
    Uart_TxEmpty(0);

    /*********** UART0 Rx test with interrupt ***********/
    rUCON0=0x45;    //tx:int rx:int

    Uart_Printf("\n[UART0 Rx 中断测试]:按任意键!!!\n");
    Uart_Printf("您可以看到按下了哪个键。按Enter键退出。\n");
    Uart_TxEmpty(0);

    rINTMSK=~(BIT_GLOBAL|BIT_URXD0);

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

    rINTMSK=~BIT_GLOBAL;
    Uart_Printf("\n");
    Test_Uart0Fifo();	//UART0 FIFO TEST
    Return_Port();
    
}


void __irq Uart0_RxInt(void)
{
    rI_ISPC=BIT_URXD0;
    
	 switch(rUERSTAT0 & 0xf)//to clear and check the status of register bits
    {
	case '1':
	    Uart_Printf("溢出错误!!!!\n");
	    break;
	case '2':
	    Uart_Printf("奇偶校验错误!!!!\n");
	    break;
	case '4':
	    Uart_Printf("帧错误!!!!\n");
	    break;
	case '8':
	    Uart_Printf("中止检测!!!!\n");
	    break;
	default :
	    break;
    }
    //Uart_Printf("UERSTAT0 = 0x%x\n", rUERSTAT0 & 0xf);
	
    keyBuf[keyBufWrPt++]=RdURXH0();
    if(keyBufWrPt==KEY_BUFLEN)
		keyBufWrPt=0;
}

//unsigned int txcount=0;
void __irq Uart0_TxInt(void)
{
//    rI_ISPC=BIT_UTXD0; //This cann't make the pending bit be cleared in the level trigger mode.

    if(*uart0TxStr != '\0')
    {
	WrUTXH0(*uart0TxStr++);
	rI_ISPC=BIT_UTXD0; //Because UART operates using level trigger mode.
    }
    else
//    {
//	rUCON0 &= 0x3f3;    //workaround
//	rI_ISPC=BIT_UTXD0;  //This cann't make the pending bit be cleared in the level trigger mode.
//	rINTMSK|=BIT_UTXD0;
//    }
//    WrUTXH0('@');
    {				//ES3
	rINTMSK |= BIT_UTXD0;	//ES3
	rI_ISPC=BIT_UTXD0;	//ES3
    }				//ES3
}
/********** UART0 FIFO TEST *******/
void Test_Uart0Fifo(void)
{
    int key;

    //Uart_Port();
    keyBufRdPt=keyBufWrPt=0;
    pISR_UTXD0=(unsigned)Uart0_TxFifoInt;
    pISR_URXD0=(unsigned)Uart0_RxFifoInt;
    pISR_UERR01=(unsigned)Uart0_RxFifoErrorInt;

    /*********** UART0 Tx FIFO test with interrupt ***********/     
    Uart_Printf("\n[UART0 Tx FIFO 中断测试]\n");
    Uart_TxEmpty(0);	//wait until tx shifter is empty.

    uart0TxStr="UART0 Tx FIFO 中断测试通过!!!!\r\n";
    rUFCON0=(2<<6)|(1<<4)|(6)|1;
    //FIFO trigger:tx/rx:8byte,tx/rx_fifo reset(will be cleared),FIFO enable.
    rUCON0 = 0x244;	//tx:levl,rx:edge,error int,normal*2,interrupt(Start)
    rINTMSK=~(BIT_GLOBAL|BIT_UTXD0);

    Delay(500);
    /*********** UART0 Tx FIFO test with BDMA0 ***********/ 
    Uart_Init(0,115200);
    Uart_Printf("\n[UART0 Tx FIFO 在BDMA0方式测试]\n");
    uart0TxStr="UART0 Tx FIFO 在BDMA0方式测试通过!!!!\r\n";
    Uart_TxEmpty(0);

    rUCON0=0x48;	//tx:BDMA0 rx:disable

    rBDICNT0=0;
    rBDCON0 =0x0;
    rBDISRC0=(unsigned int)uart0TxStr|(0<<30)|(1<<28);  // byte,inc
    rBDIDES0=UTXH0 |(1<<30)|(3<<28);  //L/B endian,M2IO,fix
    rBDICNT0=strlen((char *)uart0TxStr)|(2<<30)|(1<<26)|(0<<20); //UART0,start,polling
    rBDICNT0 |= (1<<20); //enable

    while(!((rBDCON0&0x30)==0x20));        
    Uart_TxEmpty(0);
    
    /*********** UART0 Rx FIFO test with interrupt ***********/ 
    rUCON0=0x245|0x80;	//tx:level,rx:edge,tx/rx:int,rcv_time_out enabled,error int enable

    Uart_Printf("\n[UART0 Rx FIFO 中断测试]:按任意键!!!\n");
    Uart_Printf("您可以看到按下了哪个键。按Enter键退出。\n");

    rINTMSK=~(BIT_GLOBAL|BIT_URXD0|BIT_UERR01);

    while( (rUFSTAT0&0xf) >0 )
        key=RdURXH0();  //To clear the Rx FIFO
    //rUERSTAT0;	        //To clear the uart Rx error state registers

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

    rUFCON0=(2<<6)|(1<<4)|(6)|0;  
    //FIFO trigger:tx/rx:8byte, txrx_fifo reset(will be cleared), FIFO disable.

    rINTMSK=~BIT_GLOBAL;
    rUCON0=0x45;	//rcv_time_out disabled
    Uart_Printf("\n");
    //Return_Port();
}


void __irq Uart0_TxFifoInt(void)
{
    while( !(rUFSTAT0 & 0x200) && (*uart0TxStr != '\0') )   //until tx fifo full or end of string
    {
	rUTXH0=*uart0TxStr++;
	//for(i=0;i<700;i++); //to avoid overwriting FIFO
    }

    rI_ISPC=BIT_UTXD0;        
    if(*uart0TxStr == '\0')
//	SET_INTMSK_IRQ(BIT_UTXD0);//work around for ES2
    {				//ES3
	rINTMSK |= BIT_UTXD0;	//ES3
	rI_ISPC=BIT_UTXD0;	//ES3
    }				//ES3
}


void __irq Uart0_RxFifoInt(void)
{
    rI_ISPC=BIT_URXD0;
//  if(rUFSTAT0==0)
//	Uart_Printf("time out\n");
    while( (rUFSTAT0&0xf) >0 )	    //until FIFO is empty
    {
	keyBuf[keyBufWrPt++]=rURXH0;//rx buffer->keyBuf[]
	if(keyBufWrPt==KEY_BUFLEN)
	    keyBufWrPt=0;
    }
}


void __irq Uart0_RxFifoErrorInt(void)
{
    rI_ISPC=BIT_UERR01;
   
   
    while( (rUFSTAT0&0xf) >0 )
    {
	    keyBuf[keyBufWrPt++]=rURXH0;
	    if(keyBufWrPt==KEY_BUFLEN)
		    keyBufWrPt=0;
    }
}
	


////////UART 1 TEST////////////////

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("[UART1 Tx 中断测试]\n");
    Uart_Printf("请将串口插头插到UART1插座!!!! \n");
    Uart_Printf("串口插头插到UART1后，按下任意键进行该测试。\n");
    Uart_Select(1);
    Uart_Getch();

    uart1TxStr="UART1 Tx 中断测试通过!!!!\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 在BDMA1方式测试]\n");
    uart1TxStr="UART1 Tx 在BDMA1方式测试通过!!!!\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[UART1 Rx 中断测试]:按任意键!!!!\n");
    Uart_Printf("您可以看到按下了哪个键。按Enter键退出。\n");

    rINTMSK=~(BIT_GLOBAL|BIT_URXD1);

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

    rINTMSK=~BIT_GLOBAL;
    Uart_Printf("\n");
	Test_Uart1Fifo(); //UART1 FIFO TEST
    Uart_Printf("在退出该测试之前请将串口插头插到UART0插座!!!!\n");
    Uart_Printf("串口插头插到UART0后，按下任意键退出该测试。\n");
    Uart_Select(0);
    Uart_Getch();
    Return_Port();
}


void __irq Uart1_RxInt(void)
{
    rI_ISPC=BIT_URXD1;
    
     switch(rUERSTAT1)//to clear and check the status of register bits
    {
	case '1':
	    Uart_Printf("溢出错误!!!!\n");
	    break;
	case '2':
	    Uart_Printf("奇偶校验错误!!!!\n");
	    break;
	case '4':
	    Uart_Printf("帧错误!!!!\n");
	    break;
	case '8':
	    Uart_Printf("中止检测!!!!\n");
	    break;
	default :
	    break;
    }

    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
}
	/********** UART1 FIFO TEST **********/
void Test_Uart1Fifo(void)
{
    int key;
    //Uart_Port();
    keyBufRdPt=keyBufWrPt=0;
    pISR_UTXD1=(unsigned)Uart1_TxFifoInt;
    pISR_URXD1=(unsigned)Uart1_RxFifoInt;
    pISR_UERR01=(unsigned)Uart1_RxFifoErrorInt;

    /*********** UART1 Tx FIFO test with interrupt ***********/     
    Uart_Printf("\n[UART1 Tx FIFO 中断测试]\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();
	Uart_TxEmpty(1);	//wait until tx shifter is empty.
    uart1TxStr="UART1 Tx FIFO 中断测试通过!!!!\r\n";
    rUFCON1=(2<<6)|(1<<4)|(6)|1;
    //FIFO trigger:tx/rx:8byte,tx/rx_fifo reset(will be cleared),FIFO enable.
    rUCON1 = 0x244;             //rx:edge,tx:level,error int,normal*2,interrupt(Start)    
    rINTMSK=~(BIT_GLOBAL|BIT_UTXD1);

    Delay(500);
    /*********** UART1 Tx FIFO test with BDMA1 ***********/ 
    Uart_Init(0,115200);
    Uart_Printf("\n[UART1 Tx FIFO 在BDMA1方式测试]\n");
    uart1TxStr="UART1 Tx FIFO 在BDMA0方式测试通过!!!!\r\n";
    Uart_TxEmpty(1);

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

    rBDICNT1=0;
    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,start,polling
    rBDICNT1 |= (1<<20); //enable

    while((rBDCON1&0x30)==0x10);        
    Uart_TxEmpty(1);
    
    /*********** UART1 Rx FIFO test with interrupt ***********/ 
    rUCON1=0x245|0x80;	//rx:edge,tx:level,tx/rx:int,rcv_time_out enabled,error int enable

    Uart_Printf("\n[UART1 Rx FIFO 中断测试]:按任意键!!!!\n");
    Uart_Printf("您可以看到按下了哪个键。按Enter键退出。\n");

    rINTMSK=~(BIT_GLOBAL|BIT_URXD1|BIT_UERR01);
    keyBufRdPt=keyBufWrPt=0;
    while( (rUFSTAT1&0xf) >0 )
	key=RdURXH1();  //To clear the Rx FIFO
    //rUERSTAT1;          //To clear the uart Rx error state registers

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

    rUFCON1=(2<<6)|(1<<4)|(6)|0;  
    //FIFO trigger:tx/rx:8byte, txrx_fifo reset(will be cleared), FIFO disable.

    rINTMSK=~BIT_GLOBAL;
    rUCON1=0x45;	//rcv_time_out disabled
    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_TxFifoInt(void)
{
    int i;
    while( !(rUFSTAT1 == 16) && (*uart1TxStr != '\0') )   //until tx fifo full or end of string
    {
	rUTXH1=*uart1TxStr++;
	for(i=0;i<700;i++); //to avoid overwriting FIFO
    }

    rI_ISPC=BIT_UTXD1;
    if(*uart1TxStr == '\0')
//	SET_INTMSK_IRQ(BIT_UTXD1);//work around for ES2
    {				//ES3
	rINTMSK |= BIT_UTXD1;	//ES3
	rI_ISPC=BIT_UTXD1;	//ES3
    }				//ES3
}


void __irq Uart1_RxFifoInt(void)
{
    rI_ISPC=BIT_URXD1;
//  if(rUFSTAT1==0)
//	Uart_Printf("time out\n");
    while( (rUFSTAT1&0xf) >0 )	    //until FIFO is empty
    {
	keyBuf[keyBufWrPt++]=rURXH1;	//rx buffer->keyBuf[]
	if(keyBufWrPt==KEY_BUFLEN)
	    keyBufWrPt=1;
    }
}


void __irq Uart1_RxFifoErrorInt(void)
{
    rI_ISPC=BIT_UERR01;

    while( (rUFSTAT1&0xf) >0 )
    {
	keyBuf[keyBufWrPt++]=rURXH1;
	if(keyBufWrPt==KEY_BUFLEN)
	    keyBufWrPt=0;
    }
}