uart0.c

2410得测试程序

#include <string.h>
#include <stdlib.h>
#include "2410addr.h"
#include "2410lib.h"
#include "def.h"
#include "uart0.h"

void Uart_Port_Set(void);
void Uart_Port_Return(void);

void __irq Uart0_TxInt(void);
void __irq Uart0_RxIntOrErr(void);
void __irq Uart0_TxDmaDone(void);
void __irq Uart0_RxDmaDone(void);
void __irq Uart0_RxDmaOrErr(void);
void __irq Uart0_TxFifo(void);
void __irq Uart0_RxFifoOrErr(void);
void __irq Uart0_AfcTx(void);
void __irq Uart0_AfcRxOrErr(void);

void __sub_Uart0_RxInt(void);
void __sub_Uart0_RxFifo(void);
void __sub_Uart0_RxAfc(void);
void __sub_Uart0_RxErrInt(void);

volatile U16 rx_dncs;
volatile U32 rx_point,rx_isdone,rx_filesize,rx_checksum;
volatile U32 isDone,isTxInt,isRxInt,tx_cnt,tx_end,rx_cnt,rx_end,afc_err;
volatile U8 *txdataPt;
volatile U8 *txdataFl;
volatile U8 *rxdataPt;
volatile U8 *rxdataCk;

volatile U32 save_rGPHCON,save_rGPHDAT,save_rGPHUP;
volatile U32 save_ULCON0,save_UCON0,save_UFCON0,save_UMCON0;
volatile U32 save_ULCON1,save_UCON1,save_UFCON1,save_UMCON1;
volatile U32 save_ULCON2,save_UCON2,save_UFCON2,save_UMCON2;

volatile static char *uart0TxStr;
volatile static char *uart0RxStr;

//volatile static char *uart2TxStr;
//volatile static char *uart2RxStr;

void Uart_Port_Set(void)
{
	//Push UART GPIO port configuration
	save_rGPHCON=rGPHCON; 
	save_rGPHDAT=rGPHDAT;
	save_rGPHUP=rGPHUP;
	//Configure UART port
	rGPHCON&=0x3c0000;
	rGPHCON|=0x2faaa;	// nRTS1,nCTS1
	rGPHUP|=0x1ff;	//Uart port pull-up disable
	//rINTSUBMSK=0x7ff;	//SUBINT ALL MASK
	//Push Uart control registers 
	save_ULCON0=rULCON0;			
	save_UCON0=rUCON0;			
	save_UFCON0=rUFCON0;			
	save_UMCON0=rUMCON0;			
	save_ULCON1=rULCON1;		
	save_UCON1 =rUCON1;		
	save_UFCON1=rUFCON1;		
	save_UMCON1=rUMCON1;	
	save_ULCON2=rULCON2;		
	save_UCON2 =rUCON2;		
	save_UFCON2=rUFCON2;		
	save_UMCON2=rUMCON2;		
	//Initialize UART1,2 port
}		
		
void Uart_Port_Return(void)
{		
	//Pop UART GPIO port configuration
	rGPHCON=save_rGPHCON;
	rGPHDAT=save_rGPHDAT;
	rGPHUP=save_rGPHUP;
	//Pop Uart control registers 
	rULCON0=save_ULCON0;			
	rUCON0 =save_UCON0;		
	rUFCON0=save_UFCON0;			
	rUMCON0=save_UMCON0;			
	rULCON1=save_ULCON1;		
	rUCON1 =save_UCON1;	
	rUFCON1=save_UFCON1;		
	rUMCON1=save_UMCON1;
	rULCON2=save_ULCON2;		
	rUCON2 =save_UCON2;	
	rUFCON2=save_UFCON2;		
	rUMCON2=save_UMCON2;		
}

void Uart_Uclk_En(int ch,int baud)
{
	/*
	int ch, baud;
	Uart_Printf("\nSelect UART channel[0:UART0/1:UART1/2:UART2]:\n");
	ch=Uart_GetIntNum();
	Uart_Printf("\nSelect baud rate :\n");
	baud=Uart_GetIntNum();
	*/
	if(ch == 0) {
		Uart_Select(0);
		rUCON0|=0x400;	// Select UCLK
		rUBRDIV0=( (int)(UCLK/16./baud) -1 );	//Baud rate divisior register
		Uart_Printf("UCLK is enabled by UART0.\n"); 
	}
	else if(ch==1){
		Uart_Select(1);
		rUCON1|=0x400;	// Select UCLK
		rUBRDIV1=( (int)(UCLK/16./baud) -1 );	//Baud rate divisior register
		Uart_Select(0);
		Uart_Printf("UCLK is enabled by UART1.\n");
	}
	else {
		Uart_Select(2);
		rUCON2|=0x400;	// Select UCLK
		rUBRDIV2=( (int)(UCLK/16./baud) -1 );	//Baud rate divisior register
		Uart_Select(0);
		Uart_Printf("UCLK is enabled by UART2.\n");
	}
	//for(i=0;i<100;i++);	// For the satble operation
}

void Uart_Pclk_En(int ch, int baud)
{
	/*
	int ch, baud;
	Uart_Printf("\nSelect UART channel[0:UART0/1:UART1/2:UART2]:\n");
	ch=Uart_GetIntNum();
	Uart_Printf("\nSelect baud rate :\n");
	baud=Uart_GetIntNum();
	*/
	if(ch == 0) {
		Uart_Select(0);
		rUCON0&=0x3ff;	// Select PCLK
		rUBRDIV0=( (int)(PCLK/16./baud) -1 );	//Baud rate divisior register
		Uart_Printf("PCLK is enabled by UART0.\n"); 
	}
	else if(ch==1){
		Uart_Select(1);
		rUCON1|=0x3ff;	// Select PCLK
		rUBRDIV1=( (int)(PCLK/16./baud) -1 );	//Baud rate divisior register
		Uart_Select(0);
		Uart_Printf("PCLK is enabled by UART1.\n");
	}
	else {
		Uart_Select(2);
		rUCON2|=0x3ff;	// Select PCLK
		rUBRDIV2=( (int)(PCLK/16./baud) -1 );	//Baud rate divisior register
		Uart_Select(0);
		Uart_Printf("PCLK is enabled by UART2.\n");
	}
	//for(i=0;i<100;i++);	// For the satble operation
}

//---------------------------------------UART0 test function-------------------------------------
void __irq Uart0_TxInt(void)
{
	rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);	// Just for the safety
	if(*uart0TxStr != '\0') 
	{
		WrUTXH0(*uart0TxStr++);
		ClearPending(BIT_UART0);		// Clear master pending
		rSUBSRCPND=(BIT_SUB_TXD0);		// Clear Sub int pending
		rINTSUBMSK&=~(BIT_SUB_TXD0);	// Unmask sub int
	}
	else
	{
		isTxInt=0;
		ClearPending(BIT_UART0);		// Clear master pending
		rSUBSRCPND=(BIT_SUB_TXD0);		// Clear Sub int pending
		rINTMSK|=(BIT_UART0);
	}
}

void __irq Uart0_RxIntOrErr(void)
{
	rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
	if(rSUBSRCPND&BIT_SUB_RXD0)
		__sub_Uart0_RxInt();
	else
		__sub_Uart0_RxErrInt();
	ClearPending(BIT_UART0); 
	rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_ERR0);	// Clear Sub int pending	
	rINTSUBMSK&=~(BIT_SUB_RXD0|BIT_SUB_ERR0);	
}

void __sub_Uart0_RxInt(void)
{
	if(RdURXH0()!='\r') 
	{
		Uart_Printf("%c",RdURXH0());
		*uart0RxStr++ =(char)RdURXH0();
	}
	else
	{
		isRxInt=0;
		*uart0RxStr='\0';
		Uart_Printf("\n");
	}
}

void __sub_Uart0_RxErrInt(void)
{
	switch(rUERSTAT0)//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;
	}
}

void Test_Uart0_Int(void)
{
	Uart_Port_Set(); 
	Uart_Select(0);	
	/*********** UART0 Tx test with interrupt ***********/	
	isTxInt=1;
	uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART0 Tx interrupt test is good!!!!\r\n";
	Uart_Printf("[Uart channel 0 Tx Interrupt Test]\n");

	pISR_UART0=(unsigned)Uart0_TxInt;

	rULCON0=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
	rUCON0 &= 0x400;	// For the PCLK <-> UCLK fuction
	rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
	//Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:int
	Uart_TxEmpty(0); //wait until tx buffer is empty.
	rINTMSK=~(BIT_UART0);
	rINTSUBMSK=~(BIT_SUB_TXD0);

	while(isTxInt);
	
	/*********** UART0 Rx test with interrupt ***********/
	isRxInt=1;
	uart0RxStr=(char *)UARTBUFFER;
	Uart_Printf("\n[Uart channel 0 Rx Interrupt Test]:\n");
	Uart_Printf("After typing ENTER key, you will see the characters which was typed by you.");
	Uart_Printf("\nTo quit, press ENTER key.!!!\n");
	Uart_TxEmpty(0); //wait until tx buffer is empty.
	pISR_UART0 =(unsigned)Uart0_RxIntOrErr;
	rULCON0=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
	rUCON0 &= 0x400;	// For the PCLK <-> UCLK fuction
	rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
	//Clock,Tx:pulse,Rx:pulse,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int

	// Clear Int Pending and Unmask	
	ClearPending(BIT_UART0);
	rINTMSK=~(BIT_UART0);
	rSUBSRCPND=(BIT_SUB_TXD0|BIT_SUB_RXD0|BIT_SUB_ERR0);	
	rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_ERR0);
	
	while(isRxInt);
	
	rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK|=(BIT_UART0);
 
	Uart_Printf("%s\n",(char *)UARTBUFFER);
	Uart_Port_Return();
}

void __irq Uart0_TxDmaDone(void)
{
	rDMASKTRIG0=0x0;	// Stop Dma0
	isDone=0;
	rINTMSK |= BIT_DMA0;
	ClearPending(BIT_DMA0);
}

void __irq Uart0_RxDmaOrErr(void)
{
	rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
	if(rSUBSRCPND&BIT_SUB_ERR0)
		Uart_Printf("Error : UART0 Rx Interrupt is occured!!!\n");
	else
		__sub_Uart0_RxErrInt();
	
	ClearPending(BIT_UART0);
	rSUBSRCPND=(BIT_SUB_ERR0);	// Clear Sub int pending	
	rINTSUBMSK&=~(BIT_SUB_ERR0);	
}

void __irq Uart0_RxDmaDone(void)
{
	rDMASKTRIG0=0x0;	//DMA0 Channel Off
	isDone=0;
	*(uart0RxStr+5)='\0';
	rINTMSK|=(BIT_DMA0);
	ClearPending(BIT_DMA0);
}

void Test_Uart0_Dma(void)
{
	Uart_Port_Set(); 
	Uart_Select(0);	
	/*********** UART0 Tx test with DMA0 ***********/ 
	isDone=1;
	uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART0 Tx Test by DMA0 is good!!!!\r\n";
	Uart_Printf("\n[Uart channel 0 DMA0 Tx Test]\n");
	Uart_TxEmpty(0);
	
	pISR_DMA0 =(unsigned)Uart0_TxDmaDone;

	rULCON0=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
	rUCON0 &= 0x400;	// For the PCLK <-> UCLK fuction	
	rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(2<<2)|(0);
	//Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:dma0,Rx:x

	/***DMA0 init***/
	rDISRC0=(U32)uart0TxStr;	// Start address
	rDISRCC0=(0<<1)|(0);		// AHB,Increment
	rDIDST0=(U32)UTXH0;			// Memory buffer Address
	rDIDSTC0=(1<<1)|(1);		// APB,Fixed
	rDCON0=((U32)1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(1<<24)|(1<<23)|(1<<22)|(0<<20)|strlen((char*)uart0TxStr);
	//handshake, sync PCLK, TC int, single tx, single service, Uart0, H/W request,auto-reload off, Byte size Tx, Tx count value
	rINTMSK=~(BIT_DMA0);
	rDMASKTRIG0=(0<<2)|(1<<1)|(0);	//no-stop, DMA0 channel on, no-SW trigger