adc.c

s3c24a0固件测试代码 ? ? ? ? ?啊

/*****************************************
  NAME: adc.c
  DESC: S3C24A0 ADC Test
  HISTORY:  2002.04.29:draft ver 0.0
 *****************************************/

#include <string.h>
#include "24a0addr.h"
#include "24a0lib.h"
#include "adc.h"
#include "def.h"
#include "ts.h"

volatile U32 preScaler;
volatile U32 adcDone;

void AdcDisplayFunction(void);
void Test_Adc(void);
int ReadAdc(int ch);	        
void Test_Adc_Memory(void);
void Test_Adc_Interrupt(void);
void __irq ADC_Int(void);
void __irq TS_Auto_Int(void);
void __irq TS_Sep_Int(void);
void Test_Ts_Auto(void);
void Test_Ts_Sep(void);

volatile U32 tsStatus;
volatile U32 tsTrue;


void * adc_function[][2]=
{
	
	(void *)Test_Adc	,						"ADC Test                         ",
	(void *)Test_Adc_Memory,				"ADC Test  with memory    ",
	(void *)Test_Adc_Interrupt,				"ADC Test  using interrupt  ",
	(void *)Test_Ts_Auto,						"Touch Test using auto       ",
	(void *)Test_Ts_Sep,						"Touch Test using sep        ",
	0,0
};

void __irq ADC_Int(void)
{
	rINTSUBMSK|=(BIT_SUB_ADC|BIT_SUB_PENDN|BIT_SUB_PENUP);
	rSUBSRCPND=BIT_SUB_ADC;
	Uart_Printf("%04d\n", rADCDAX&0x3ff);
	adcDone=1;
	ClearPending(BIT_ADC_PENUP_DOWN);
	rINTSUBMSK&=~(BIT_SUB_ADC);

}

void __irq TS_Auto_Int(void)
{
    unsigned int WHATIRQ=0;

    rINTSUBMSK|=(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);	// Mask sub interrupt (ADC, PENUP and PENDN) 

    WHATIRQ = (rSUBSRCPND>>17)&0x7;
	switch(WHATIRQ){
		case 1:
		       rSUBSRCPND=BIT_SUB_PENUP;
		       tsStatus=1;
			tsTrue=1;
			break;
		case 2:
			if(tsStatus==1) {
				rSUBSRCPND=BIT_SUB_PENDN;
				tsStatus=2;
				tsTrue=1;
			    	rADCTSC=(0<<8)|(1<<3)|(1<<2)|(0);
				rADCCON|=0x1;// Start Auto X-Y conversion
			}	
			else {
				rSUBSRCPND=BIT_SUB_PENDN;
				break;				
			}
			break;
		case 4:
			rSUBSRCPND=BIT_SUB_ADC;
			tsStatus=4;
			tsTrue=1;
		default:
		break;
	}

	rINTSUBMSK &= ~(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN); 
	rSRCPND=(1<<31);
	rINTPND=(1<<31);
}


void __irq TS_Sep_Int(void)
{
	int i;
	U32 Pt[6];
	unsigned int WHATIRQ=0;
 
	 rINTSUBMSK|=(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);  // Mask sub interrupt (ADC, PENUP and PENDN) 
 
	 WHATIRQ = (rSUBSRCPND>>17)&0x7;
	 switch(WHATIRQ){
		 case 1:
			rSUBSRCPND=BIT_SUB_PENUP;
			tsStatus=1;
			tsTrue=1;
			 break;
		 case 2:
			 if(tsStatus==1) {
				 rSUBSRCPND=BIT_SUB_PENDN;
				 tsStatus=2;
				 tsTrue=1;
				 rADCTSC=(0<<8)|(1<<3)|(0<<2)|(1);//Down,Pullup Dis,Normal,X-position
				 rADCCON|=0x1;// Start X conversion
			 }	 
			 else {
				 rSUBSRCPND=BIT_SUB_PENDN;
				 break; 			 
			 }
			 break;
		 case 4:
			 rSUBSRCPND=BIT_SUB_ADC;
			 tsStatus=4;
			 tsTrue=1;
		 default:
			 break;
	 }
 
	 rINTSUBMSK &= ~(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN); 
 //    ClearPending(BIT_ADC_PENUP_DOWN);
	 rSRCPND=(1<<31);
	 rINTPND=(1<<31);
 	
 
}

/*
void __irq TS_Sep_Int(void)
{
	int i;
	U32 Pt[6];
	unsigned int WHATIRQ=0;

	
	rINTSUBMSK|=(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);	// Mask sub interrupt (ADC, PENUP and PENDN) 

	WHATIRQ = (rSUBSRCPND>>17) & 0x3;
	switch(WHATIRQ) {
		case 1:
		case 3:
			Uart_Printf("\nStylus Up!!\n");	
			rSUBSRCPND=BIT_SUB_PENUP;//Clear Sub-Source Pending, PENUP
			rINTSUBMSK&=~(BIT_SUB_PENUP);//Unmask Sub-Interrupt, PENUP
			break;
		case 2:
			Uart_Printf("\nStylus Down!!\n");
			// <X-Position Read>
			rADCTSC=(0<<8)|(1<<3)|(0<<2)|(1);//Down,Pullup Dis,Normal,X-position
			for(i=0;i<LOOP;i++);		//delay to set up the next channel
			for(i=0;i<5;i++) {
				rADCCON|=0x1;		// Start X-position conversion
				while(rADCCON & 0x1);	// Check if Enable_start is low
				while(!(0x8000&rADCCON));	// Check ECFLG
				Pt[i]=(0x3ff&rADCDAX);
			}
			Pt[5]=(Pt[0]+Pt[1]+Pt[2]+Pt[3]+Pt[4])/5;
			Uart_Printf("X-Posion[AIN5] is %04d\n", Pt[5]);

			// <Y-Position Read>
			rADCTSC=(0<<8)|(1<<3)|(0<<2)|(2);// Down,Pullup Dis,Normal,Y-position
			for(i=0;i<LOOP;i++);		//delay to set up the next channel
			for(i=0;i<5;i++) {
				rADCCON|=0x1;		// Start Y-position conversion
				while(rADCCON & 0x1);	// Check if Enable_start is low
				while(!(0x8000&rADCCON));	// Check ECFLG
				Pt[i]=(0x3ff&rADCDAY);
			}
			Pt[5]=(Pt[0]+Pt[1]+Pt[2]+Pt[3]+Pt[4])/5;
			Uart_Printf("Y-Posion[AIN7] is %04d\n", Pt[5]);
	
			rADCTSC=(0<<8)|(13<<4)|(0<<3)|(0<<2)|1;//for returning to X-position....
			rADCTSC=0xd3; //for waiting interruupt
			while(((rSUBSRCPND>>17)&0x02) !=0x2);
			rSUBSRCPND=BIT_SUB_PENDN|BIT_SUB_ADC;//Clear Sub-Source Pending, PENDN

	
			rINTSUBMSK&=~(BIT_SUB_PENDN);//Unmask sub-interrupt, PENDN	
			break;
		default:
			break;
	}

	ClearPending(BIT_ADC_PENUP_DOWN);
}
*/


void AdcDisplayFunction(void)
{
	int i;

	i=0;	
	Uart_Printf("\n\n");
	while(1)	{   //display menu
	    Uart_Printf("%2d:%s",i,adc_function[i][1]);
	    i++;
	    if((int)(adc_function[i][0])==0) {
			Uart_Printf("\n");
			break;
	    }
	    if((i%2)==0) Uart_Printf("\n");
	}
}

void Ch30_ADC(void)
{
	int i;

	while(1) {
		AdcDisplayFunction();
		Uart_Printf("\nSelect(-1 to exit): ");
		i = Uart_GetIntNum();
		//Uart_Printf("IN:%d.\n\n", i);
		if(i==-1) break;
		
		if(i>=0 && (i<(sizeof(adc_function)/8)) ) 
	    	( (void (*)(void)) (adc_function[i][0]) )();	// execute selected function.
	}

}


//==================================================================================
void Test_Adc(void)
{
    int i,key,j;
    int a0=0,a1=0,a2=0,a3=0,a4=0,a5=0,a6=0,a7=0; //Initialize variables
    int value;
    
    Uart_Printf("[ ADC_IN Test ]\n");
    Uart_Printf("0. Dispaly Count 100     1. Continued ...\n\n");
    Uart_Printf("Select : ");
    key = Uart_GetIntNum();
    Uart_Printf("\n\n");    
        
    Uart_Printf("The ADC_IN are adjusted to the following values.\n");	      
    Uart_Printf("Push any key to exit!!!\n");	 

    Uart_Printf("ADC conv. freq. = %dHz\n",ADC_FREQ);
    preScaler = PCLK/(ADC_FREQ) -1;               //PCLK:50.7MHz
    Uart_Printf("preScaler:%d\n", preScaler);
    //ADC conversion time = 5CYCLES*(1/(ADC Freq.)), ADC Freq. = PCLK/(ADCPSR+1)

    //pISR_ADC_PENUP_DOWN=(unsigned)Adc_Manual;
    //rINTMSK=~(BIT_ADC_PENUP_DOWN);
    //rINTSUBMSK=~(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);	
    
    Uart_Printf("PCLK/ADC_FREQ - 1 = %d\n",preScaler);

	Uart_Printf("rADCCON:%x\n", rADCCON);
    if (key == 0)
    {

	Uart_Printf("Select the channel[0~3]:\n");
	j=Uart_GetIntNum();
	
	while(1) {
		for(i=0; i<REQCNT; i++) {
			value=ReadAdc(j);
			Uart_Printf("%04d\n", value);
		}
		Uart_Printf("Conversion is done!!\n");
		Uart_Printf("Press Enter key to exit, any key to continue\n");
		if(Uart_Getch()=='\r') break;
	}
    }
    else if(key == 1)
    {
        while(Uart_GetKey()==0)
        {
	    a0=ReadAdc(0);
	    a1=ReadAdc(1);
	    a2=ReadAdc(2);
	    a3=ReadAdc(3);
	    a4=ReadAdc(4);
	    a5=ReadAdc(5);
	    a6=ReadAdc(6);
	    a7=ReadAdc(7);

	    Uart_Printf("AIN0: %04d AIN1: %04d AIN2: %04d AIN3: %04d AIN4: %04d AIN5: %04d AIN6: %04d AIN7: %04d\n", a0,a1,a2,a3,a4,a5,a6,a7);
        }        
    }

Uart_Printf("If you want to set stanbymode press any key\n");
Uart_Getch();
Uart_Printf("rADCCON:%x\n", rADCCON);
    rADCCON=rADCCON|(1<<2);  //stand by mode to reduce power consumption	

    Uart_Printf("\nrADCCON = 0x%x\n", rADCCON);
    rINTSUBMSK|=(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);
    rINTMSK|=BIT_ADC_PENUP_DOWN;
	
}


void Test_Adc_Memory(void)
{
    int i,key;

    unsigned int *dst, *tmp, ch;
	

    dst = (unsigned int *)0x12000000;

    tmp = dst;
	
    for(i=0; i<REQCNT; i++)
		*tmp++ = 0x0;
	
	Uart_Printf("ADC conv. freq. = %dHz\n", ADC_FREQ);
	Uart_Printf("Select the channel[0~3]:\n");
	ch=Uart_GetIntNum();

	while(1) {
		preScaler = PCLK/ADC_FREQ -1;               //PCLK:50.7MHz
		rADCCON = (1<<14)|(preScaler<<6)|(ch<<3);	//setup channel

		tmp = dst;
		  
		for(i=0;i<REQCNT;i++)                               //May 08, 2002 SOP
		{
			rADCCON|=0x1;	 //start ADC
			while(rADCCON & 0x1);	 //check if Enable_start is low, waiting for 0
			while(!(rADCCON & 0x8000)); //check if EC(End of Conversion) flag is high, waiting for 1
			*tmp = rADCDAX & 0x3ff;
			tmp++;
		}

		for(i=0;i<REQCNT; i++)
		Uart_Printf("%04d\n", *dst++);

		Uart_Printf("Conversion is done!!!\n");
		Uart_Printf("If you want to stop, press enter key else if you want to covert more, press any key except enter\n");
		if(Uart_Getch()=='\r') break;

	} 
	rADCCON=rADCCON|(1<<2);  //stand by mode to reduce power consumption	
    

	
}

//==================================================================================		
int ReadAdc(int ch)
{
    int i;
    static int prevCh=-1;

    rADCCON = (1<<14)|(preScaler<<6)|(ch<<3);	//setup channel

    if(prevCh!=ch)
    {
	rADCCON = (1<<14)|(preScaler<<6)|(ch<<3);   //setup channel
	for(i=0;i<LOOPADC;i++);	//delay to set up the next channel
	prevCh=ch;
    }
    rADCCON|=0x1;   //start ADC

    while(rADCCON & 0x1);	//check if Enable_start is low, waiting for 0
    while(!(rADCCON & 0x8000));	//check if EC(End of Conversion) flag is high, waiting for 1

    return ( (int)rADCDAX & 0x3ff );
}



void Test_Adc_Interrupt(void)
{
    int i,key;

	U32 ch;
	
	Uart_Printf("ADC Test using Interrupt\n");
	Uart_Printf("ADC conv. freq. = %dHz\n", ADC_FREQ);

	adcDone=0;
	pISR_ADC_PENUP_DOWN=(U32)ADC_Int;
	rINTMSK&=~(BIT_ADC_PENUP_DOWN);	
	rINTSUBMSK &= ~(BIT_SUB_ADC);

	Uart_Printf("Select the channel[0~3]:\n");
	ch=Uart_GetIntNum();

	while(1) {
		preScaler = PCLK/ADC_FREQ -1;               //PCLK:50.7MHz
		rADCCON = (1<<14)|(preScaler<<6)|(ch<<3);	//setup channel
		rADCCON|=0x1;	 //start ADC

		while(!adcDone);
		adcDone=0;
		Uart_Printf("Conversion is done!!!\n");

		Uart_Printf("Enter:stop conversion, Other:continue conversion\n");
		if(Uart_Getch()=='\r') break;
	}
	
	Uart_Printf("Press any key to continue\n");
	Uart_Getch();
	rADCCON=rADCCON|(1<<2);  //stand by mode to reduce power consumption	

	rINTSUBMSK|=(BIT_SUB_ADC);
	rINTMSK|=(BIT_ADC_PENUP_DOWN);
	
}




void Test_Ts_Auto(void)
{

	
	Uart_Printf("[Touch Screen Test.]\n");
	Uart_Printf("Auto X/Y position conversion mode test\n");

#if 0
	rGPCON_M=(rGPCON_M&~(0x3f))|(0x3f);
	rGPCON_L=(rGPCON_L&~(0x3<<20))|(0x3<<20);
#endif

	rADCDLY=(1000);	// ADC Start or Interval Delay

	// Enable Prescaler,Prescaler,AIN5/7 fix,Normal,Disable read start,No operation
	rADCCON = (1<<14)|(ADCPRS<<6)|(0<<3)|(0<<2)|(0<<1)|0;	
	    
	//rADCTSC=(0<<8)|(13<<4)|(0<<3)|(0<<2)|3;//tark, XP pullup En,Normal,Waiting for interrupt mode
	rADCTSC=0xd3;

	pISR_ADC_PENUP_DOWN=(U32)TS_Auto_Int;
	rINTMSK&=~(BIT_ADC_PENUP_DOWN);
	rINTSUBMSK&=~(BIT_SUB_PENUP|BIT_SUB_PENDN|BIT_SUB_ADC);

	Uart_Printf("\nType any key to exit!!!\n");
	Uart_Printf("\nStylus Down, please...... \n");

	tsTrue=0;
	while(1) {
		while(!tsTrue) 
			if(Uart_GetKey()) { 	
				rINTSUBMSK|=(BIT_SUB_PENUP|BIT_SUB_PENDN|BIT_SUB_ADC);
				rINTMSK|=BIT_ADC_PENUP_DOWN;
				Uart_Printf("[Touch Screen Test is done]\n");
				return;
			}

		tsTrue=0;
		switch(tsStatus) {
			case 1:
				Uart_Printf("Stylue Up!\n");
				break;
			case 2:
				Uart_Printf("Stylue Down!\n");
				break;
			case 4:
				Uart_Printf("X-Posion[AIN5] is %04d\n", (0x3ff&rADCDAX));
				Uart_Printf("Y-Posion[AIN7] is %04d\n", (0x3ff&rADCDAY));
				rADCTSC=(0<<8)|(13<<4)|(0<<3)|(0<<2)|1;//for returning to X-position....
				rADCTSC=0xd3; //for waiting interruupt
				break;
			default:
				break;
		}
	}	
		
	rINTSUBMSK|=(BIT_SUB_PENUP|BIT_SUB_PENDN|BIT_SUB_ADC);
	rINTMSK|=BIT_ADC_PENUP_DOWN;
	Uart_Printf("[Touch Screen Test is done]\n");
}



void Test_Ts_Sep(void)
{


	U32 whatposition;
	
	Uart_Printf("[Touch Screen Test.]\n");
	Uart_Printf("Auto X/Y position conversion mode test\n");

#if 0
	rGPCON_M=(rGPCON_M&~(0x3f))|(0x3f);
	rGPCON_L=(rGPCON_L&~(0x3<<20))|(0x3<<20);
#endif

	rADCDLY=(1000);	// ADC Start or Interval Delay

	// Enable Prescaler,Prescaler,AIN5/7 fix,Normal,Disable read start,No operation
	rADCCON = (1<<14)|(ADCPRS<<6)|(0<<3)|(0<<2)|(0<<1)|0;	
	    
	//rADCTSC=(0<<8)|(13<<4)|(0<<3)|(0<<2)|3;//tark, XP pullup En,Normal,Waiting for interrupt mode
	rADCTSC=0xd3;

	pISR_ADC_PENUP_DOWN=(U32)TS_Sep_Int;
	rINTMSK&=~(BIT_ADC_PENUP_DOWN);
	rINTSUBMSK&=~(BIT_SUB_PENUP|BIT_SUB_PENDN|BIT_SUB_ADC);

	Uart_Printf("\nType any key to exit!!!\n");
	Uart_Printf("\nStylus Down, please...... \n");

	tsTrue=0;
	whatposition=0;
	while(1) {		
		while(!tsTrue) 
     			if(Uart_GetKey()) { 	
				rINTSUBMSK|=(BIT_SUB_PENUP|BIT_SUB_PENDN|BIT_SUB_ADC);
				rINTMSK|=BIT_ADC_PENUP_DOWN;
				Uart_Printf("[Touch Screen Test is done]\n");
				return;
     			}	
		tsTrue=0;
		switch(tsStatus) {
			case 1:
				Uart_Printf("Stylue Up!\n");
				break;
			case 2:
				Uart_Printf("Stylue Down!\n");
				break;
			case 4:
				if(whatposition==0) {
					Uart_Printf("X-Posion[AIN5] is %04d\n", (0x3ff&rADCDAX));
					whatposition=1;					
					rADCTSC=(0<<8)|(1<<3)|(0<<2)|(2);// Down,Pullup Dis,Normal,Y-position
					rADCCON|=0x1;// Start Y conversion
				}
				else if(whatposition==1) {
					Uart_Printf("Y-Posion[AIN7] is %04d\n", (0x3ff&rADCDAY));
					whatposition=0;					
					rADCTSC=(0<<8)|(13<<4)|(0<<3)|(0<<2)|1;//for returning to X-position....
					rADCTSC=0xd3; //for waiting interruupt
				}	
				break;
			default:
				break;
		}
	}	
		
	rINTSUBMSK|=(BIT_SUB_PENUP|BIT_SUB_PENDN|BIT_SUB_ADC);
	rINTMSK|=BIT_ADC_PENUP_DOWN;
	Uart_Printf("[Touch Screen Test is done]\n");
}


/*
void Test_Ts_Sep(void)
{
	Uart_Printf("[Touch Screen Test.]\n");
	Uart_Printf("Separate X/Y position conversion mode test\n");

#if 1	
	rGPCON_M=(rGPCON_M&~(0x3f))|(0x3f);
	rGPCON_L=(rGPCON_L&~(0x3<<20))|(0x3<<20);
#endif
	//    rPWRMAN=0x2;
	rADCDLY=(1000);	// ADC Start or Interval Delay

	// Enable Prescaler,Prescaler,AIN7/5 fix,Normal,Disable read start,No operation
	rADCCON = (1<<14)|(ADCPRS<<6)|(0<<3)|(0<<2)|(0<<1)|(0);
   
	//rADCTSC=(0<<8)|(14<<3)|(0<<2)|(3);	// Down,XP pullup En,Normal,Waiting for interrupt mode
	rADCTSC=0xd3;
	

	pISR_ADC_PENUP_DOWN=(U32)TS_Sep_Int;
	rINTMSK&=~(BIT_ADC_PENUP_DOWN);
	rINTSUBMSK&=~(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);


	Uart_Printf("\nType any key to exit!!!\n");
	Uart_Printf("\nStylus Down, please...... \n");
    
	Uart_Getch();

	rINTSUBMSK|=(BIT_SUB_ADC|BIT_SUB_PENUP|BIT_SUB_PENDN);
	rINTMSK|=BIT_ADC_PENUP_DOWN;

	Uart_Printf("[Touch Screen Test.]\n");
}
*/