uart2.c

samsung arm2440开发板 数模转换测试程序

    /***DMA3 init***/
    rDISRC3=(U32)URXH2;			// Start address
    rDISRCC3=(1<<1)|(1);		// APB,Fixed
    rDIDST3=(U32)uart2RxStr;	// Memory buffer Address
    rDIDSTC3= (0<<1)|(0);		// AHB,Increment
    rDCON3=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(0<<24)|(1<<23)|(1<<22)|(0<<20)|(5);
    //handshake, sync PCLK, TC int, single tx, single service, Uart2, H/W request,auto-reload off, Byte size Tx, Tx count value

    // Clear Int Pending and Unmask
    ClearPending(BIT_UART2);
    rINTMSK=~(BIT_DMA3|BIT_UART2);
    rSUBSRCPND=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
    rINTSUBMSK=~(BIT_SUB_ERR2);
    rDMASKTRIG3=(0<<2)|(1<<1)|(0);    //no-stop, DMA3 channel on, no-SW trigger 

    while(isDone);

    Uart_Printf("%s\n",uart2RxStr);
    

    //----------------------------------------------------------------------------------------->    
    Uart_Printf("Jumper Setting  <======>  J16: 2-3, J18:2-3");
    Uart_Printf("\nConnect PC[COM1 or COM2] and UART1 of SMDK2440 with a serial cable!!! \n");
    Uart_Printf("Then, press any key........\n");
    Uart_Select(1);
    Uart_Getch();
    //--------------------------->


    Uart_Port_Return();
}

void Test_Uart2_Fifo(void)
{
    Uart_Port_Set(); 
    // Additional configuration for UART2 port
    //rGPHCON&=0x3fafff;      // TXD2,RXD2

    Uart_Select(1);
    /******* UART2 Tx FIFO test with interrupt ********/     
    Uart_Printf("[Uart channel 2 Tx FIFO Interrupt Test]\n");
    Uart_TxEmpty(1);	//wait until tx buffer is empty.
    
    //-------------------------------------------------------------------------------------------->
    Uart_Printf(" Jumper Setting  <======> J17:2-3, J19:2-3, J16: 1-2, J18:1-2");
    Uart_Printf("\nConnect PC[COM1 or COM2] and UART2 of SMDK2440 with a serial cable!!! \n");
    Uart_Printf("Then, press any key........\n");
    Uart_Select(2);	// Change the uart port    
    Uart_Getch();
    //----------------------------------------->
    
    
    /* <Tx Trigger Level:8Byte> */    
    uart2TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART2 Tx FIFO interrupt(8byte) test is good!!!!\r\n";
    pISR_UART2=(U32)Uart2_TxFifo;
    rULCON2=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
    rUCON2 |= (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
    rUFCON2=(2<<6)|(1<<4)|(1<<2)|(1<<1)|(1);
    //Tx and Rx FIFO Trigger Level:8byte,Tx and Rx FIFO Reset,FIFO on
    rINTMSK=~(BIT_UART2);
    rINTSUBMSK=~(BIT_SUB_TXD2);
    Delay(500);
    rUFCON2=(2<<6)|(1<<4)|(1<<2)|(1<<1)|(0);
    //Tx and Rx FIFO Trigger Level:8byte,Tx and Rx FIFO Reset,FIFO off

    /* <Tx Trigger Level:12Byte> */    
    uart2TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART2 Tx FIFO interrupt(12byte) test is good!!!!\r\n";
    pISR_UART2=(unsigned)Uart2_TxFifo;
    rULCON2=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
    rUCON2 |= (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
    rUFCON2=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(1);
    //Tx and Rx FIFO Trigger Level:12byte,Tx and Rx FIFO Reset,FIFO on
    rINTMSK=~(BIT_UART2);
    rINTSUBMSK=~(BIT_SUB_TXD2);
    Delay(500);
    rUFCON2=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
    //Tx and Rx FIFO Trigger Level:12byte,Tx and Rx FIFO Reset,FIFO off

    
    /******* UART2 Rx FIFO test with interrupt ********/     
    rx_dncs=0;
    rx_point=0;
    rx_isdone=1;
    rx_filesize=0;
    rx_checksum=0;
    Uart_Printf("[Uart channel 2 Rx FIFO Interrupt Test]\n");

    pISR_UART2=(unsigned)Uart2_RxFifoOrErr;

    rULCON2=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
    rUCON2 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(1<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
    //Clock,Tx:Def,Rx:Def,Rx timeout:o,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int
    rUFCON2=(1<<6)|(0<<4)|(1<<2)|(1<<1)|(1);
    //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx FIFO Reset,FIFO on

    // Clear Int Pending and Unmask 
    ClearPending(BIT_UART2);
    rINTMSK=~(BIT_UART2);
    rSUBSRCPND=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
    rINTSUBMSK=~(BIT_SUB_RXD2|BIT_SUB_ERR2);

    Uart_Printf("Download the target file[*.bin] by Uart2\n");
	
    while(rx_isdone);

    rINTMSK |= (BIT_UART2);	
    rINTSUBMSK|=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);

    rUFCON2=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
    //Tx and Rx FIFO Trigger Level:12byte,Tx and Rx FIFO Reset,FIFO off
			
    if(rx_dncs==(rx_checksum&0xffff)) 
	Uart_Printf("\nDownload test OK!!!\n");
    else 
	Uart_Printf("\nError!!!\n");


    //----------------------------------------------------------------------------------------->    
    Uart_Printf("Jumper Setting  <======>  J16: 2-3, J18:2-3");
    Uart_Printf("\nConnect PC[COM1 or COM2] and UART1 of SMDK2440 with a serial cable!!! \n");
    Uart_Printf("Then, press any key........\n");
    Uart_Select(1);
    Uart_Getch();
    //--------------------------->


    Uart_Port_Return();	
}
void GPS_Inf_Show(void)
{
	char ch;
	Uart_Port_Set();
	 /******* UART2 Rx FIFO test with interrupt ********/   
	 
    
    Uart_Printf("[Uart channel 2 Rx FIFO Interrupt Test for GPS Inf,YOYO]\n");
    
	/******** For operating clock test *********/
	Uart_Printf("Select operating clock 1. PCLK(D)    2. UCLK     3. FCLK/n  \nChoose : ");
	ch = Uart_Getch();
	switch (ch)
	{
	case '2' :
		Uart_Uextclk_En(2, 115200, 14745600);
		break;
	case '3' :
		Uart_Fclkn_En(2, 115200);
		break;
	default :
		//Uart_Pclk_En(2, 115200);
		Uart_Pclk_En(2, 9600);
	}
	
	/******** Select UART or IrDA *********/
	Uart_Printf("Select 1. UART or 2. IrDA(D) mode\nChoose : ");
	if (Uart_Getch() == '1')
		rULCON2 &= ~(1<<6); // UART mode
	else
		rULCON2 |= (1<<6); // IrDA mode
    /*********** UART2 Rx test with interrupt ***********/
    isRxInt=1;
    uart2RxStr=(volatile char *)UARTBUFFER;
    Uart_Printf("\n[Uart channel 2 Rx Interrupt Test GPS Inf]:\n");
     
    pISR_UART2 =(unsigned)Uart2_RxIntOrErr;

    rULCON2=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
    rUCON2 |= (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_UART2);
    rINTMSK=~(BIT_UART2);
    rSUBSRCPND=(BIT_SUB_RXD2|BIT_SUB_ERR2);
    rINTSUBMSK=~(BIT_SUB_RXD2|BIT_SUB_ERR2);

    Uart_Printf("Press any key to stop GPS Inf \n");
    Uart_Getch();

    rINTSUBMSK|=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
    rINTMSK|=(BIT_UART2);

    Uart_Printf("%s\n",(char *)UARTBUFFER);
    
	Uart_Port_Return();
}
void GSM_AT_COMMAND(void)
{
	char ch,i;
	char comm[10],sd[10];

	Uart_Port_Set();
	 /******* UART0 Rx FIFO test with interrupt ********/   
	 
    
    Uart_Printf("[Uart channel 0 Rx/Tx FIFO Interrupt Test for GSM AT COMMAND,YOYO]\n");

    GSM_Power_Up();
    
	/******** For operating clock test *********/
	Uart_Printf("Select operating clock 1. PCLK(D)    2. UCLK     3. FCLK/n  \nChoose : ");
	//ch = Uart_Getch();
	ch='1';
	switch (ch)
	{
	case '2' :
		Uart_Uextclk_En(0, 115200, 14745600);
		break;
	case '3' :
		Uart_Fclkn_En(0, 115200);
		break;
	default :
		//Uart_Pclk_En(2, 115200);
		Uart_Pclk_En(0, 115200);
	}
	
	/******** Select UART or IrDA *********/
	Uart_Printf("Select 1. UART or 2. IrDA(D) mode\nChoose : ");
	//if (Uart_Getch() == '1')
		rULCON0 &= ~(1<<6); // UART mode
//	else
	//	rULCON0 |= (1<<6); // IrDA mode
    /*********** UART0 Rx test with interrupt ***********/
    isRxInt=0;
    uart0RxStr=(volatile char *)UARTBUFFER;
    Uart_Printf("\n[Uart channel 0 Rx Interrupt Test GSM AT COMMAND]:\n");
     
    pISR_UART0 =(unsigned)Uart0_RxIntOrErr_YOYO;

    rULCON0=(0<<6)|(0<<3)|(0<<2)|(3);	// Normal,No parity,One stop bit, 8bit
    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_RXD0|BIT_SUB_ERR0);
    rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_ERR0);

    Uart_Printf("Please Input ATC,AT COMMAND Test one by one \n");

    Uart_Printf("Connect COM1 to COM0,Press ~ exit\n");

	i=0;
	UART0_F_Pointer=0;
	UART0_F_Pointer=0;
	while(1)
		{
		
    		ch= Uart_Getch();
			if(ch=='~' ) break;
			if(ch==0x0d && i>=2)
				{
					comm[i++]=0x0d;
					comm[i++]=0x0a;
					comm[i]=0;
					Uart_Select(0);
					Uart_SendString(comm);
					Delay(20);
					i=0;
					comm[i]=0;
					Uart_Select(1);
					Uart_SendByte('\n');
				}
			else if(i==0 && (ch=='a'||ch=='A'))
				{
				comm[i++]=ch;
				comm[i]=0;
				
				Uart_Select(1);
				Uart_SendByte((int)ch);
				}
			else if(i==1 &&(ch=='t'||ch=='T'))
				{
					comm[i++]=ch;
					comm[i]=0;
					
					Uart_Select(1);
					Uart_SendByte((int)ch);
				}
			else if(i>=2)
				{
					comm[i++]=ch;
					comm[i]=0;
					Uart_Select(1);
					Uart_SendByte((int)ch);
				}
			if(UART0_F_Pointer != UART0_R_Pointer && UART0_R_Pointer>3 && UART0_RX[UART0_R_Pointer-1]==0x0a)
			{
					Uart_Select(1);
					Uart_SendString(UART0_RX);
					//UART0_RX[0]=0;
					UART0_F_Pointer=0;
					UART0_R_Pointer=0;
			}
		}
			
	Uart_Select(1);
	Uart_Printf("\nPlease press any key to close test\n");
	Uart_Getch();
    rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
    rINTMSK|=(BIT_UART0);

    //Uart_Printf("%s\n",(char *)UARTBUFFER);
    
	Uart_Port_Return();
}
void GSM_Power_Up(void)
{
	int i,j;
	rGPGCON &=~(3<<18);   //GPG9=GPRS_PWRKEY
	rGPGCON |=(1<<18);//output
	rGPGUP |=(1<<9);

	rGPBCON &=~(3<<0);   //GPB0=GPRS_RUN_DETECT
	rGPBCON |=(0<<0);//input
	rGPBUP |=(1<<0);
	
	rGPHCON &=~(3<<2); //GPH1=RTS0
	rGPHCON |=(1<<2);
	rGPHUP |=(1<<1);
	
	rGPGDAT |=GPRS_PWRKEY;
	rGPHDAT &=~(1<<1); //RTS0=0;
	
	Delay(2000);
	Delay(2000);
	Delay(2000);
	Delay(2000);
	Delay(2000);
	rGPGDAT &=~GPRS_PWRKEY;
	Delay(2000);
	Delay(2000);
	Delay(2000);
	Delay(2000);
	Delay(2000);
	Delay(2000);
	Delay(2000);	
	rGPGDAT |=GPRS_PWRKEY;
	Delay(50);
	Delay(2000);
	Delay(2000);
	Delay(2000);
	for(i=0;i<500;i++)
		{
			j=rGPBDAT&0x01;
		}
	if(j==0)
		{
			Uart_Printf("GSM Power Off\n");
		}
	else
		{
			Uart_Printf("GSM Power On\n");
		}
}