uarttest.c

samsung 最新芯片2450 的测试程序.

};


//interrupt 
bool TestUartbyModePingpongtestInt()
{
	bool bret =0;
	int failnum=0;
	int i=0;
	int j=0;
	int jstart=0;

	//g_UART_TXdatasize=1024;
	//g_UART_TXdatasize=1048574;
	g_UART_TXdatasize=10485760;
	g_UART_RXdatasize=g_UART_TXdatasize;
	g_UART_portTx=3;	
	g_UART_portRx=3;	
	
	g_pTxString= (char* )UART_TXBUF;
	g_pRxString= (char* )UART_RXBUF;
	UART_TxstrMake(g_pTxString, g_UART_TXdatasize);

	if(g_UART_bTXtest)//tx
	{
		for(i=0;i<100;i++)
		{
			for(j=2;j<5;j++)
			{
				Delay(150000);//100us order 1sec
				//Delay(100000);//100us order 1sec
				bret=TestUartbyModePingpongUnit(g_UART_portTx,	&UartConINTTxP[j],  0,0);//with out afc
				
				if(!bret) failnum++;				
				printf("fail num : %d\n", failnum);			
			}
			for(j=2;j<4;j++)
			{
				Delay(150000);//100us order 1sec
				//Delay(100000);//100us order 1sec
				bret=TestUartbyModePingpongUnit(g_UART_portTx,	&UartConINTTxP[j],  0,0);//with out afc
				
				if(!bret) failnum++;				
				printf("fail num : %d\n", failnum);			
			}
			

			if(i==30) g_UART_portTx =2;
			else if(i==70) g_UART_portTx =0;	
			//jstart=(jstart==2)?0:jstart+1;
		}
	}
	else//rx
	{
		for(i=0;i<100;i++)
		{
			for(j=2;j<5;j++)
			{
				UART_RxBufferClear(g_pRxString, g_UART_RXdatasize+2);
				bret=TestUartbyModePingpongUnit(g_UART_portRx,	&UartConINTRxP[j],  0,0);//with out afc
				if(!bret) failnum++;
				printf("fail num : %d\n", failnum);			
			}	
			for(j=2;j<4;j++)
			{
				UART_RxBufferClear(g_pRxString, g_UART_RXdatasize+2);
				bret=TestUartbyModePingpongUnit(g_UART_portRx,	&UartConINTRxP[j],  0,0);//with out afc
				if(!bret) failnum++;
				printf("fail num : %d\n", failnum);			
			}			
			if(i==40) g_UART_portRx =2;
			else if(i==70) g_UART_portRx =0;						
		}		
	}
	if(!failnum) return 1;
	else return 0;	
};


//Polling
bool TestUartbyModePingpongtestPolling()
{
	bool bret =0;
	int failnum=0;
	int i=0;
	int j=0;

	//g_UART_TXdatasize=1024;
	//g_UART_TXdatasize=1048574;
	g_UART_TXdatasize=10485760;
	g_UART_RXdatasize=g_UART_TXdatasize;
	g_UART_portTx=3;	
	g_UART_portRx=3;	
	
	g_pTxString= (char* )UART_TXBUF;
	g_pRxString= (char* )UART_RXBUF;
	UART_TxstrMake(g_pTxString, g_UART_TXdatasize);

	if(g_UART_bTXtest)//tx
	{
		for(i=0;i<100;i++)
		{
			for(j=0;j<5;j++)
			{
				Delay(100000);//100us order 1sec
				//Delay(30000);//100us order 1sec
				bret=TestUartbyModePingpongUnit(g_UART_portTx,	&UartConPollingTxP[j],  0,0);//with out afc
				
				if(!bret) failnum++;				
				printf("fail num : %d\n", failnum);	
				
				if(i==33) g_UART_portTx =2;
				else if(i==66) g_UART_portTx =0;						
			}
		}
	}
	else//rx
	{
		for(i=0;i<100;i++)
		{
			for(j=0;j<5;j++)
			{
				UART_RxBufferClear(g_pRxString, g_UART_RXdatasize+2);
				bret=TestUartbyModePingpongUnit(g_UART_portRx,	&UartConPollingRxP[j],  0,0);//with out afc
				if(!bret) failnum++;
				printf("fail num : %d\n", failnum);		
				
				if(i==30) g_UART_portRx =2;
				else if(i==70) g_UART_portRx =0;
			}			
		}		
	}
	if(!failnum) return 1;
	else return 0;	
};



void TestUartbyModeUnit(unsigned char ch, UART_CON* pUartCon,
						    void (*func_start)(void), bool (*func_test)(void))
{
	int strsize;
	bool bret;

	UART_assignUartCon(ch, pUartCon);
	UART_userguide(ch);	
	UART_SelectOpClock(pUartCon->cOpClock);
	if( UartOpen(ch,1,(bool)pUartCon->fAfc) == SENDBREAK ) 
	{
		printf("\n\nSend Break Signal has been transfered");
		return; 	
	} 	

	printf("\npress enter to start test\n");
	getchar();
	
	// UART Tx test with interrupt	
	printf("\n[Uart channel %d Tx Test]\n",ch);	
	g_pTxString= (char* )UART_TXBUF;
	//UART_TxstrMake(g_pTxString, 10);
	//UART_TxstrMake(g_pTxString, 1024);
	//UART_TxstrMake(g_pTxString, 1048576);	
	UART_TxstrMake(g_pTxString, g_UART_TXdatasize);
		
	TxString(ch, g_pTxString, g_UART_TXdatasize, func_start, func_test);
	printf("\nTx Done~ \n");			
		
	printf("press enter to rx\n");

	printf("0x%x : rxfifo 0 \n", rUFSTAT0 );

	// UART Rx test with interrupt 
	g_pRxString= (char* )UART_RXBUF;
	UART_RxBufferClear(g_pRxString, g_UART_RXdatasize+2);//1mbyte
	
	printf("\n[Uart channel %d Rx Test]\n",ch);
	printf("Case 1 : Interrupt mode. After typing characters and pressing ENTER key.\n");
	printf("Case 2 : Interrupt FIFO mode & DMA mode. After typing characters and pressing ENTER key until FIFO level trigger.\n");	
	printf(" Then, you will see those characters.\n");
	//printf("\nRx : %s \n",RxString(ch));
	g_pRxString=RxString(ch, (char *)UART_RXBUF, &bret, 0, 0);
	if(g_pRxString!=0)
	{
		bret = UART_RxstrVerify(g_pRxString, g_UART_RXdatasize);
		printf("RX test result : %d,  including return : %d\n", bret, g_UART_RXdatasize);
		UART_RxstrPrint(g_pRxString, 100);		
	}
	printf("\nRx Done~ \n");


	// Test End
	printf("\nComplete UART test!!! \n");
	UartClose(ch, UART_DUPLEX0);
	SetDbgUart(1); // change channel setting for debug port set
}

void TestTxRxUartbyModeUnit(unsigned char Txch, UART_CON* pUartConTx,
						   unsigned char Rxch, UART_CON* pUartConRx,
						    void (*func_start)(void), bool (*func_test)(unsigned char, unsigned char))
{
	int strsize;
	bool bret;

	UART_assignUartCon(Txch, pUartConTx);
	UART_assignUartCon(Rxch, pUartConRx);
	UART_userguide(Txch);	
	UART_userguide(Rxch);
	UART_SelectOpClock(pUartConTx->cOpClock);
	UART_SelectOpClock(pUartConRx->cOpClock);
	UartOpen(Txch,1,(bool)pUartConTx->fAfc);
	UartOpen(Rxch,1,(bool)pUartConRx->fAfc);

	printf("\npress enter to start test\n");
	getchar();
	
	g_pTxString= (char* )UART_TXBUF;
	g_pRxString= (char* )UART_RXBUF;
	UART_TxstrMake(g_pTxString, g_UART_TXdatasize);
	UART_RxBufferClear(g_pRxString, g_UART_RXdatasize+2);//1mbyte	
	bret = TxRxString(Txch, g_pTxString, Rxch, g_pRxString,func_start, func_test);
	if(g_pRxString!=0)
	{
		bret = UART_RxstrVerify(g_pRxString, g_UART_RXdatasize);
		printf("RX test result : %d,  including return : %d\n", bret, g_UART_RXdatasize);
		UART_RxstrPrint(g_pRxString, 100);		
	}
	printf("\nTxRx Done~ \n");

	// Test End
	printf("\nComplete UART test!!! \n");
	UartClose(Txch, UART_DUPLEX0);
	UartClose(Rxch, UART_DUPLEX1);
	SetDbgUart(1); // change channel setting for debug port set
}



/*typedef struct tag_UART_CON
{
	unsigned int iBaudrate;
	unsigned char fSelUartIrda; // 0 : Uart mode 1: IrDA mode
	unsigned char fLoopTest;  // UCON[5]  (0 : normal, 1 : LoopBack)
	unsigned char fAfc;		//AFC mode - 0:disable, 1:enable
	unsigned char fEnableFifo; // Fifo -0 : disable 1: enable
	
	unsigned char cOpClock; 	// 0,2:PCLK, 1:UEXTCLK, 3:EPLL
	unsigned char cDataBit; 	// 0:5bit, 1:6bit, 2:7bit, 3:8bit
	unsigned char cParityBit; 	// 0:no parity, 1:odd, 2:even, 3:forced 1, 4:forced 0
	unsigned char cStopBit; 	// 0:one stopbit, 1:two stopbit
	unsigned char cTxMode; 	// 0:disable, 1:interrupt or polling, 2:DMA0, 3:DMA1
	
	unsigned char cTxTrig; 	// 0:empty, 1:16, 2:32, 3:48 (byte)
	unsigned char cRxMode; 	// 0:disable, 1:interrupt or polling, 2:DMA0, 3:DMA1
	unsigned char cRxTrig; 	// 0:1, 1:8, 2:16, 3:32 (byte)
	unsigned char cRtsTrig; 	// 0:63, 1:56, 2:48, 3::40, 4:32, 5:24, 6:16, 7:8 (byte)
	unsigned char cSendBreakSignal;  // ULCON[4]  (0 : normal, 1 : Send Break Signal)
	
	//additional information
	unsigned char cTxIntType;  //0: pulse, 1: level
	unsigned char cRxIntType;  //0: pulse, 1: level
	bool 		  bTxPolling;  //0: interrupt 1: polling.
	bool 		  bRxPolling;  //0: interrupt 1: polling.
	bool			  bRXTimeOuten;	//0: disable 1: enable
	
	bool			  bRXErrorInten;	//0: disable 1: enable
	unsigned char cDmaRxDMD_HS;//0: demand 1: handshake
	unsigned char cDmaRxTSZ;		//0: single  1: burst
	unsigned char cDmaTxDMD_HS;	//0: demand 1: handshake
	unsigned char cDmaTxTSZ;		//0: single  1: burst	
} UART_CON;
*/
//default
//{115200,0,0,0,0,  0,3,0,0,1,  1,1,1,1,0,  0,0,0,0,0,  0,1,0,1,0}




//												 /-- 0 : non fifo 1 : fifo
//												/		/- interrupt
//interrupt test                                                /           /   /-tx trigger level
//											    |           |   | 		    /-0. pulse  1 : level
static UART_CON	UartConTest[] = 		 {{115200,0,0,0,0,  2,3,0,0,1,  1,0,1,1,0,  0,0,0,0,0,  0,1,0,1,0}
									, {1200,0,0,0,1,  2,3,0,0,1,  0,0,1,1,0,  0,0,0,0,0,  0,1,0,1,0}
									, {1200,0,0,0,1,  2,3,0,0,1,  1,0,1,1,0,  0,0,0,0,0,  0,1,0,1,0}
									, {1200,0,0,0,1,  2,3,0,0,1,  2,0,1,1,0,  0,0,0,0,0,  0,1,0,1,0}
									, {1200,0,0,0,1,  2,3,0,0,1,  3,0,1,1,0,  0,0,0,0,0,  0,1,0,1,0}}; 

//												 /-- 0 : non fifo 1 : fifo
//												/		/- tx interrupt (1)
//interrupt test                                                /           /   /-tx trigger level(1:16)
//											    |           |   | /-rx interrput (1)
//											    |           |   | |  /- rx trigger level(3:32)
//											    |           |   | |  |       /- 0 : tx pulse
//											    |           |   | |  |	   | /- 0 : rx pulse
//											    |           |   | |  |       | |  /- 0 : tx interrupt
//											    |           |   | |  |       | |  | /- 0 : rx interrupt
//											    |           |   | |  |       | |  | |      /- 1: rx error interrupt
static UART_CON	UartConINTTx = 	 {115200  ,0,0,0,1,  3,3,0,0,1,  1,0,0,1,0,  0,0,0,0,0,  0,1,0,2,0};
static UART_CON	UartConINTRx = 	 {115200  ,0,0,0,1,  3,3,0,0,0,  0,1,3,1,0,  0,0,0,0,0,  0,1,0,2,0};



static UART_CON	UartDefault = {115200,0,0,0,0,  2,3,0,0,1,  1,1,1,1,0,  0,0,1,1,0,  0,1,0,1,0};
static UART_CON	UartGPIO = {10000,0,0,0,0,  2,3,0,0,1,  1,1,1,1,0,  0,0,1,1,0,  0,1,0,1,0};
									
//tx polling, rx interrupt test							     / 2:for pclk 3; epll(7) for low speed
static UART_CON	UartConTestRXINT[] = 		 {{115200	,0,0,0,0,  2,3,0,0,1,  0,0,1,1,0,  0,0,1,0,0,  0,1,0,1,0}
														  	 //tx                //tx
										, {115200	,0,0,0,0,  2,3,0,0,0,  0,1,1,1,0,  0,0,0,0,0,  0,1,0,1,0}}; 
															 	  //rx        ^0:pulse, 1:level
										//20 epll level not ok.															   
										//110 pclk level :   not ok    pulse : ok.  
										//1200 pclk level :   ok    pulse : ok.  
										//115200 pclk level : .
static UART_CON	UartConTmp,UartConTmp2;
			
			
		
															   
void TestUartbyMode(void)
{
	int mode;
	printf("select mode : 0. polling  1. polling afc 2. interrupt(pulse)  3. dma(tx-0, rx1)  4. dma(tx-1, rx0)         5. interrupt(pulse) loopback ");
	
	mode = GetIntNum();
	
	printf("###TX CH %d\n", g_UART_portTx);
	printf("###Rx CH %d\n", g_UART_portRx);	
	
	switch(mode)
	{
		case 0: //polling
		printf("###polling\n");
		//TestUartbyModeUnit(g_UART_port,0,		1,1,4,		(g_UART_baudrate>1000000)?3:2,1,g_UART_baudrate,		(g_UART_bTXtest==0)?4:0,1,(g_UART_RXtest==0)?4:0,1,
		//				     0,0, 		g_UART_EnableFifo, g_UART_TxTrig,g_UART_RxTrig,  		    0,1,    1,0,   0,0);	
		UartConTmp=UartConTestRXINT[0];//polling tx
		
		UartConTmp.iBaudrate=	g_UART_baudrate;
		UartConTmp.cOpClock = (g_UART_baudrate>1000000)?3:2;
		UartConTmp.fEnableFifo=g_UART_EnableFifo;
		UartConTmp.cTxTrig = g_UART_TxTrig;
		UartConTmp.cRxTrig = g_UART_RxTrig;
		UartConTmp.cTxMode = (g_UART_bTXtest==0)?0:1;
		UartConTmp.bTxPolling=1;
		UartConTmp.cRxMode = (g_UART_bRXtest==0)?0:1;
		UartConTmp.bRxPolling=1;
		TestUartbyModeUnit(g_UART_portTx,	&UartConTmp,  0,0);		
		break;		

		case 1: //polling
		printf("###polling-afc\n");
		//TestUartbyModeUnit(g_UART_port,0,		1,1,4,		(g_UART_baudrate>1000000)?3:2,1,g_UART_baudrate,		(g_UART_bTXtest==0)?4:0,1,(g_UART_RXtest==0)?4:0,1,
		//				     0,0, 		g_UART_EnableFifo, g_UART_TxTrig,g_UART_RxTrig,  		    0,1,    1,0,   0,0);	
		UartConTmp=UartConTestRXINT[0];//polling tx
		
		UartConTmp.iBaudrate=	g_UART_baudrate;
		UartConTmp.cOpClock = (g_UART_baudrate>1000000)?3:2;
		UartConTmp.fEnableFifo=1;
		UartConTmp.fAfc=1;
		
		UartConTmp.cTxTrig = 0;
		UartConTmp.cTxMode = (g_UART_bTXtest==0)?0:1;		
		UartConTmp.bTxPolling=1;		
		
		UartConTmp.cRxTrig = 1;
		UartConTmp.cRtsTrig = 7;
		UartConTmp.cRxMode = (g_UART_bRXtest==0)?0:1;				
		UartConTmp.bRxPolling=1;
		
		TestUartbyModeUnit(g_UART_portTx,	&UartConTmp,  0,0);		
		break;		


		case 2: //interrupt - pulse
		printf("###interrupt (pulse)\n");

		UartConTmp=UartConINTTx;
		UartConTmp.iBaudrate=	g_UART_baudrate;
		UartConTmp.cOpClock = (g_UART_baudrate>1000000)?3:2;
		UartConTmp.fEnableFifo=g_UART_EnableFifo;
		UartConTmp.cTxTrig = g_UART_TxTrig;
		UartConTmp.cRxTrig = g_UART_RxTrig;
		UartConTmp.cTxIntType=0;//key is pulse, level ok .
		UartConTmp.cRxIntType=0;
		UartConTmp.cTxMode = (g_UART_bTXtest==0)?0:1;
		UartConTmp.bTxPolling=0;
		UartConTmp.cRxMode = (g_UART_bRXtest==0)?0:1;
		UartConTmp.bRxPolling=0;
		UartConTmp.bRXTimeOuten=g_UART_RXTimeOuten;
		UartConTmp.fAfc=0;
		TestUartbyModeUnit(g_UART_portTx,	&UartConTmp,  0,0);//with out afc
		
		//g_UART_TXdatasize=1024;
		//TestUartbyModeUnit(g_UART_portTx,	&UartConTest[0],  0,UART_TxFifotestINT);//ok
		//TestUartbyModeUnit(g_UART_portTx,	&UartConTest[0],  0,0);//ok
		
		
//		TestUartbyModeUnit(g_UART_port,0,		1,1,4,		(g_UART_baudrate>1000000)?3:1,1,g_UART_baudrate,		(g_UART_TXtest==0)?4:1,1,(g_UART_RXtest==0)?4:1,1,
//						     g_UART_RXTimeOuten,0, 		g_UART_EnableFifo, g_UART_TxTrig,g_UART_RxTrig,  		    0,1,    1,0,   0,0);	
		break;		
		

		
		case 3: //dma - tx0 rx1		
		printf("###dma (tx0 rx1) \n");
		
		UartConTmp=UartConINTTx;
		UartConTmp.iBaudrate=	g_UART_baudrate;
		UartConTmp.cOpClock = (g_UART_baudrate>1000000)?3:2;
		UartConTmp.fEnableFifo=g_UART_EnableFifo;
		UartConTmp.cTxTrig = g_UART_TxTrig;
		UartConTmp.cRxTrig = g_UART_RxTrig;
		UartConTmp.cTxMode = (g_UART_bTXtest==0)?0:2;
		UartConTmp.cRxMode = (g_UART_bRXtest==0)?0:3;
		UartConTmp.bRXTimeOuten=g_UART_RXTimeOuten;
		UartConTmp.cDmaRxDMD_HS=g_UART_DmaRxDMD_HS;