timer_test.c

s3c6400 ADS下官方测试程序

		PWM_stopAll();
		
		if (g_uIntCounter0 == g_uIntCounter2)
 			printf("Prescaler 1 test ==> OK!\n");
		else
			{
			printf("Prescaler 1 test ==> Fail........\n");
			uCnt++;
			}



	if (uCnt >0)
		printf("Total Prescaler 1 test Fail\n");
	else
		printf("Total Prescaler 1 test Success!!\n\n");
	

	printf("When you confirmed Timer 0, 1 's Prescaler value(Prescaler0) , this result is confirmable!!\n\n");
	
	INTC_Disable(NUM_TIMER2);
	INTC_Disable(NUM_TIMER0);

}


////////////
// File Name : TIMER_MUX234
// File Description : Check MUX2,3,4 values by Comparing with Timer0 Interrupt 
//			(SMDK6400 doesn't have TOUT[2],[3],[4] pin out therefore use Interrupt check)
// Input : NONE
// Output : NONE
// Version : 
void TIMER_MUX234(void)
{
	u32 uSelMUX;
	u32 uMux;
	u32 uCnt;
	
	printf("Which MUX do you want to check?\n");
	printf("MUX[2~4]  :");
	uSelMUX = GetIntNum();

	PWM_stopAll();	// stop timers
	INTC_SetVectAddr(NUM_TIMER0,Isr_TIMER0);
	INTC_SetVectAddr(NUM_TIMER2,Isr_TIMER2);
	INTC_SetVectAddr(NUM_TIMER3,Isr_TIMER3);	
	INTC_SetVectAddr(NUM_TIMER4,Isr_TIMER4);	
	INTC_Enable(NUM_TIMER0);
	INTC_Enable(NUM_TIMER2);
	INTC_Enable(NUM_TIMER3);
	INTC_Enable(NUM_TIMER4);

	uCnt = 0;
	
	for(uMux=0;uMux<5;uMux++)
		{

	  	g_uIntCounter0 = 0;
		g_uIntCounter2 = 0;
		g_uIntCounter3 = 0;
		g_uIntCounter4 = 0;		

		PWM_Select(uSelMUX,255,uMux,3000,1500,0,0,0,1,0,1);	
		PWM_Select(0,255,0,3000,1500,0,0,0,1,0,1);	  	


		switch(uSelMUX)
			{
			case 2:
				
				while(!(g_uIntCounter0 == 16));     
					PWM_stopAll(); //One-shot, Inverter off, No operation, Dead zone disable, Stop
			   
			    	if( (g_uIntCounter2== (0x10>>uMux)) && g_uIntCounter0==16)
			   		 {
			    			printf("Timer 2  MUX2 1/%d Test => OK!\n",(1<<uMux));
					 }        
			    	else
					 {
			       	 	printf("Timer 2  MUX2 1/%d Test => Fail............\n",(1<<uMux));
						uCnt++;
					 }    

				printf("Timer0: %d (=16)\n Timer%d: %d (=%d)\n", g_uIntCounter0,uSelMUX,g_uIntCounter2,(0x10>>uMux));        
				break;

			case 3:

				while(!(g_uIntCounter0 == 16));     
				PWM_stopAll(); //One-shot, Inverter off, No operation, Dead zone disable, Stop
			   
			    	if(g_uIntCounter3==(0x10>>uMux) && g_uIntCounter0==16)
			   		 {
			    			printf("Timer 3 MUX3 1/%d Test => OK!\n",(1<<uMux));
					 }        
			    	else
					 {
			       	 	printf("Timer 3 MUX3 1/%d Test => Fail............\n",(1<<uMux));
						uCnt++;						
					 }    

				printf("Timer0: %d (=16)\n Timer%d: %d (=%d)\n", g_uIntCounter0,uSelMUX,g_uIntCounter3,(0x10>>uMux));        
				break;

			case 4:

				while(!(g_uIntCounter0 == 16));     
				PWM_stopAll(); //One-shot, Inverter off, No operation, Dead zone disable, Stop
			   
			    	if(g_uIntCounter4==(0x10>>uMux) && g_uIntCounter0==16)
			   		 {
			    			printf("Timer 4 MUX4 1/%d Test => OK!\n",(1<<uMux));
					 }        
			    	else
					 {
			       	 	printf("Timer 4 MUX4 1/%d Test => Fail............\n",(1<<uMux));
						uCnt++;						
					 }    

				printf("Timer0: %d (=16)\n  Timer%d: %d (=%d)\n", g_uIntCounter0,uSelMUX,g_uIntCounter4,(0x10>>uMux));        
				break;

			default :
				break;
			
			}


		}


	// Timer0,1,2,3,4 Interrupt Service is masked //
		INTC_Disable(NUM_TIMER4);
		INTC_Disable(NUM_TIMER3);
		INTC_Disable(NUM_TIMER2);
		INTC_Disable(NUM_TIMER0);

	if (uCnt >0)
		printf("\nMUX %d test Fail\n",uSelMUX);
	else
		printf("\nMUX %d test Success!!\n",uSelMUX);
	

	printf("When you confirmed Timer 0's Divider value , this result is confirmable!!\n\n");

	
}


////////////
// File Name : Isr_TimerDMA
// File Description : for Timer's DMA request Interrupt Service Routine
//                           In this test, we transmitted rTCMPB0 value from memory by DMA
// Input : NONE
// Output : NONE
// Version : 
void __irq Isr_TimerDMA(void)
{
	u32 uRegTmp;
	u32 uRegTmp2;


	INTC_Disable(NUM_DMA1);

	DMACH_Stop(&oPWMDmac);
	Disp ("DMA request %d              rTCMPB value changed :%d\n",g_PWMDmaDone,PWM_ReadrTCMPB(3));
	g_PWMDmaDone--;	

	// Interrupt Clear
	DMACH_ClearErrIntPending(&oPWMDmac);
  	DMACH_ClearIntPending(&oPWMDmac);

	uRegTmp = DMACH_ReadDstAddr(&oPWMDmac);
	uRegTmp2 = DMACH_ReadSrcAddr(&oPWMDmac);			// next SrcAddress
	uRegTmp2 +=4;
	DMACH_AddrSetup(DMA_A,uRegTmp2,uRegTmp,&oPWMDmac);
	DMACH_SetTransferSize(1,&oPWMDmac);					// set TransferSize
	DMACH_Start(&oPWMDmac);

	INTC_Enable(NUM_DMA1);
	INTC_ClearVectAddr();

}


////////////
// File Name : Comp32
// File Description : This function is for Timer DMA request test. Comparing Tx/Rx memory data
// Input : a0 [Tx mem addr.]  a1[Rx mem addr.]  words[length]
// Output : false/true
// Version : 
bool Comp32(u32 a0, u32 a1, u32 words)
{
	u32* pD0 = (u32 *)a0;
	u32* pD1 = (u32 *)a1;
	bool ret = true;
	u32  ecnt = 0;
	u32 i;

	for (i=0; i<words; i++)
	{
		if (*pD0 != *pD1) 
		{
			ret = false;
			Disp(" %08x=%08x <-> %08x=%08x\n", pD0, *pD0, pD1, *pD1);
			ecnt++;
		}
		pD0++;
		pD1++;
	}

	if (ret == false)
		Disp("\n");

	return ret;
}


////////////
// File Name : TIMER_Dma
// File Description : This is test function for Timer DMA request which transmit rTCMPB value from MEM to PWM regisnter
// Input : NONE
// Output : NONE
// Version : 
void TIMER_Dma(void)
{
	// SMDK6400 _DRAM_BaseAddress + 0x800_0000;
	u32 uTxBuffAddr = _DRAM_BaseAddress + 0x1000000;
	u32 uCnt;
	u32 uDataCnts;

	SYSC_SelectDMA(eSEL_PWM, 1);
	
     	DMAC_InitCh(DMA1, DMA_A, &oPWMDmac);
	INTC_SetVectAddr(NUM_DMA1,  Isr_TimerDMA);
	INTC_Enable(NUM_DMA1);

	DMACH_ClearErrIntPending(&oPWMDmac);
  	DMACH_ClearIntPending(&oPWMDmac);
	
       Disp("\nSelect Transfer Size [1~150] :   ");
	uDataCnts=GetIntNum();
	Disp("\n");

	g_PWMDmaDone = uDataCnts;
	   	
	// Set up the tx buf.
	for (uCnt = 0; uCnt<uDataCnts; uCnt++)
		*((u32 *)(uTxBuffAddr)+uCnt) = (u32)(uCnt*200);
	
	
        // Channel, LLI_Address, SrcAddr, Src Type, DstAddr, Dst Type, Transfer Width, Transfer Size, OpMode(DEMAND), Src Req, Dst Req, Burst
        // Channel Set-up
	DMACH_Setup(DMA_A, 0x0, uTxBuffAddr, 0, 0x7f006034, 1, WORD,1, DEMAND, MEM,DMA1_PWM,SINGLE, &oPWMDmac);


        // Enable DMA
	DMACH_Start(&oPWMDmac);

	//Start Timer0 with DMA request
	PWM_Select(3,50,4,30000,15000,0,0,1,1,0,1);

	while(g_PWMDmaDone>0);


	DMACH_Stop(&oPWMDmac);


}


////////////
// File Name : WDT_IntReq
// File Description : This function checks WDT Interrupt by changing division factor, prescaler value & WTDAT
// Input : NONE
// Output : NONE
// Version : 
void WDT_IntReq(void)
{
	s32 sDiv;
	u32 uPrescaler;
	u32 uWTdat;
	
	// WDT ISR addr Initialization // 

	INTC_SetVectAddr(NUM_WDT,Isr_WDT);	
	g_uIntCounterWT = 0;

	//f_watchdog = PCLK / (Prescaler value + 1 ) / Division_factor
	printf("[WatchDog Timer Interrupt Request Test]\n");

	/* WDT INTMSK Enable */
	INTC_Enable(NUM_WDT);


	/* WDT Interrupt Test */

	// 1. Clock division_factor test
	printf("\n1. Clock division factor test\n");
	sDiv = 0;
	uPrescaler = 0;
	uWTdat = 50000;
	while(sDiv <= 3)
		{
	g_uIntCounterWT = 0;		
	printf("\nClock Division Factor: %d(dec), Prescaler: %d(dec)\n",(1<<(sDiv+4)),uPrescaler+1);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);
	sDiv++;
		}
#if 1
	// 2. Clock Prescaler_factor test
	printf("\n2. Prescaler value test\n");

	uPrescaler = 0;
	uWTdat = 5000;
	while( uPrescaler <= 60)
		{
		sDiv =1;
		g_uIntCounterWT = 0;
		printf("\nClock Division Factor: %d(dec), Prescaler: %d(dec)\n",(1<<(sDiv+4)),uPrescaler);
		WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
		while(g_uIntCounterWT <10);
		uPrescaler=uPrescaler+20;
		}

	
	while( uPrescaler <= 0xff)
		{
		sDiv =0;
		g_uIntCounterWT = 0;
		printf("\nClock Division Factor: %d(dec), Prescaler: %d(dec)\n",(1<<(sDiv+4)),uPrescaler);
		WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
		while(g_uIntCounterWT <10);
		uPrescaler=uPrescaler+20;
		}


	sDiv =0;
	uPrescaler = 255;
	uWTdat = 5000;
	g_uIntCounterWT = 0;
	printf("\nClock Division Factor: %d(dec), Prescaler: %d(dec)\n",(1<<(sDiv+4)),uPrescaler);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);

#endif
	
	// 2. WTDAT value test
	printf("\n3. WTDAT test\n");
	sDiv =1;
	uPrescaler = 0;
	uWTdat = 0xffff;

	g_uIntCounterWT = 0;
	printf("\nWTDAT: %d(dec)\n",uWTdat);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);

	uWTdat = 0xfff0;
	g_uIntCounterWT = 0;
	printf("\nWTDAT: %d(dec)\n",uWTdat);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);

	uWTdat = 0xff00;
	g_uIntCounterWT = 0;
	printf("\nWTDAT: %d(dec)\n",uWTdat);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);

	uWTdat = 0xf000;
	g_uIntCounterWT = 0;
	printf("\nWTDAT: %d(dec)\n",uWTdat);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);


	sDiv =3;
	uPrescaler = 100;
	uWTdat = 1000;

	g_uIntCounterWT = 0;
	printf("\nWTDAT: %d(dec)\n",uWTdat);
	WDT_operate(0,1,(u32)sDiv,1,uPrescaler,uWTdat,uWTdat);
	while(g_uIntCounterWT != 10);

	

	/* WDT Reset Test */
    printf("\nI will restart after 2 sec.\n");
	g_uIntCounterWT = 0;
	WDT_operate(1,1,0,1,100,31250,31250);    


 
	while(!UART_GetKey());
	INTC_Disable(NUM_WDT);


}


////////////
// File Name : WDT_Rest
// File Description : This function checks watchdog reset
// Input : NONE
// Output : NONE
// Version : 
void WDT_Reset(void)
{
    
	// WDT ISR addr Initialization // 

	INTC_SetVectAddr(NUM_WDT,Isr_WDT);	
	g_uIntCounterWT = 0;

	printf("[WatchDog Timer Reset Test]\n");

	INTC_Enable(NUM_WDT);
	
	// 1. Clock division_factor 128
	printf("\nClock Division Factor: 1(dec), Prescaler: 100(dec)\n");
	WDT_operate(0,1,0,1,100,15625,15625);

    printf("WDT Reset after wdt interrupt happened 5 times. \n");	   

	while(g_uIntCounterWT != 5); // variable
 
    // WDT reset enable
    printf("\nI will restart after 2 sec.\n");
	g_uIntCounterWT = 0;
	WDT_operate(1,1,0,1,100,15625,15625);    
	
    
    while(!UART_GetKey());
	INTC_Disable(NUM_WDT);

}


////////////
// File Name : DelayfrTimer_Test
// File Description : This function checks DelayfrTimer function
// Input : NONE
// Output : NONE
// Version : 
void DelayfrTimer_Test(void)
{
	u32 cMea;
	s32 uInput;

	while(1)
	{
		printf("What do you want to have as a measurement of delay? \n");
		printf("[0: micro sec      1:milli sec]            : ");
		cMea = GetIntNum();
		printf("\n");			
		printf("How much delay do you want to have?  \n");
		printf("ex) 1 = 1msec, 100 = 100msec :          ");
		uInput = GetIntNum();
		printf("\n");	
		if(uInput== -1) 
			break;
				
		DelayfrTimer((eDelay_M)cMea,uInput);
		printf("This is %dmsec delayed time!!\n\n",uInput);
		
	}
			
}

////////////
// File Name : DelayfrTimer_Test
// File Description : This function checks Start and Stop Timer function with DelayfrTimer
// Input : NONE
// Output : NONE
// Version : 
void StartandStopTimer_Test(void)
{
	u32 uVal;
	
	StartTimer(0);

	DelayfrTimer(milli,1000);
//	for(uCn=0;uCn<5000;uCn++);

   	uVal = StopTimer(0);
	printf("%d microsecond has passed!\n",uVal);
	

}