mainbak1.c

这是用Labwindows开发的一个RF test程序。 用于日本机种的组装后ANT 测试。

	testdata->BurstLengthAvg=0;
	testdata->PowerAvg=0;
	return 0;
}


int ResetTestResult(struct TestResult*testresult)
{
	testresult->PeakPhaseErrorAvg=0;
	testresult->RMSPhaseErrorAvg=0;
	testresult->FrequencyErrorAvg=0;
	testresult->BurstLengthAvg=0;
	testresult->PowerAvg=0;
	return 0;
}

int WriteCSVFileHeader(FILE *fp)
{	
	fprintf(fp,"%s,%s,%s,%s,%s,%s,%s,%s",
			",,,,,","TEST ITEM","GSM900 Average Power","GSM900 Peak Phase Error","GSM900 RMS Phase Error","GSM1800 Average Power","GSM1800 Peak Phase Error","GSM1800 RMS Phase Error\n");
	fprintf(fp,"%s,%s,%s,%s,%s,%s,%s,%s",
			",,,,,","Channel","62","62","62","698","698","698\n");
	fprintf(fp,"%s,%s,%s,%s,%s,%s,%s,%s",
			",,,,,","NOTE","PL5","PL5","PL5","PL0","PL0","PL0\n");
	fprintf(fp,"%s,%s,%d,%d,%d,%d,%d,%d,%s",
			",,,,,","Upper Limit",
			GSM900SpecData.PowerAvgH,GSM900SpecData.PeakPhaseErrorH,GSM900SpecData.RMSPhaseErrorH,
			PCN1800SpecData.PowerAvgH,PCN1800SpecData.PeakPhaseErrorH,PCN1800SpecData.RMSPhaseErrorH,"\n");
	fprintf(fp,"%s,%s,%d,%d,%d,%d,%d,%d,%s",
			",,,,,","Lower Limit ",
			GSM900SpecData.PowerAvgL,GSM900SpecData.PeakPhaseErrorL,GSM900SpecData.RMSPhaseErrorL,
			PCN1800SpecData.PowerAvgL,PCN1800SpecData.PeakPhaseErrorL,PCN1800SpecData.RMSPhaseErrorL,"\n");
	fprintf(fp,"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s",
			"Serial Number","IMEI","TEST TIME","Station Name","Spec file name","Spec file ver","Unit","dbm","deg","deg","dbm","deg","deg\n");
	return 0;
}


FILE* OpenCSVLogFile(FILE *fp)
{
	char CSVFileName[STRINGLENGTH];
	GetCSVFileName(CSVFileName);
	if (!(fp=fopen(CSVFileName,"r")))
		//CSVFileName does not exist
	{
		//fclose(fp);
		fp=fopen(CSVFileName,"a");
		WriteCSVFileHeader(fp);
	}
	else
	{
		fclose(fp);
		fp=fopen(CSVFileName,"a");
	}
	return fp;
}

char* GetSystemYear(char *str)
{
	char year[5];
	int status;
	status = GetSystemDate (&SystemDate.month, &SystemDate.day, &SystemDate.year);	
	year[0]=SystemDate.year/1000+48;
	year[1]=(SystemDate.year-(year[0]-48)*1000)/100+48;
	year[2]=(SystemDate.year-(year[0]-48)*1000-(year[1]-48)*100)/10+48;
	year[3]=(SystemDate.year-(year[0]-48)*1000-(year[1]-48)*100-(year[2]-48)*10)+48;	
	year[4]='\0';
	strcpy(str,year);
	return str;
}

char* GetSystemMonth(char *str)
{
	char month[3];
	int status;
	status = GetSystemDate (&SystemDate.month, &SystemDate.day, &SystemDate.year);	
	month[0]=SystemDate.month/10+48;
	month[1]=SystemDate.month-(month[0]-48)*10+48;
	month[2]='\0';
	strcpy(str,month);
	return str;
}

char* GetSystemDay(char *str)
{
	char day[3];
	int status;
	status = GetSystemDate (&SystemDate.month, &SystemDate.day, &SystemDate.year);	
	day[0]=SystemDate.day/10+48;
	day[1]=SystemDate.day-(day[0]-48)*10+48;
	day[2]='\0';
	strcpy(str,day);
	return str;
}

char* GetSystemHour(char *str)
{
	char hour[3];
	int status;
	status = GetSystemTime (&SystemTime.hour,&SystemTime.minute,&SystemTime.second);
	hour[0]=SystemTime.hour/10+48;
	hour[1]=SystemTime.hour-(hour[0]-48)*10+48;
	hour[2]='\0';
	strcpy(str,hour);
	return str;
}

char* GetSystemMinute(char *str)
{
	char minute[3];
	int status;
	status = GetSystemTime (&SystemTime.hour,&SystemTime.minute,&SystemTime.second);
	minute[0]=SystemTime.minute/10+48;
	minute[1]=SystemTime.minute-(minute[0]-48)*10+48;
	minute[2]='\0';
	strcpy(str,minute);
	return str;
}

char* GetSystemSecond(char *str)
{
	char second[3];
	int status;
	status = GetSystemTime (&SystemTime.hour,&SystemTime.minute,&SystemTime.second);
	second[0]=SystemTime.second/10+48;
	second[1]=SystemTime.second-(second[0]-48)*10+48;
	second[2]='\0';
	strcpy(str,second);
	return str;
}

int InitCSVFileRecord()
{
	char time[5];
	strcpy(csvFileRecord.IMEI,"");
	strcpy(csvFileRecord.SerialNumber,"");
	strcpy(csvFileRecord.StationName,STATION_NAME);
	strcpy(csvFileRecord.SpecFileName,SPEC_FILE_NAME);
	strcpy(csvFileRecord.SpecFileVer,SPEC_FILE_VER);
	strcpy(csvFileRecord.TESTTIME,GetSystemYear(time));
	strcat(csvFileRecord.TESTTIME,GetSystemMonth(time));
	strcat(csvFileRecord.TESTTIME,GetSystemDay(time));
	strcat(csvFileRecord.TESTTIME,GetSystemHour(time));
	strcat(csvFileRecord.TESTTIME,GetSystemMinute(time));
	strcat(csvFileRecord.TESTTIME,GetSystemSecond(time));
	return 0;
}
int AddCSVFileRecord(FILE *fp)
{
	InitCSVFileRecord();
	fprintf(fp,"%s,%s,%s,%s,%s,%s,%s,%f,%f,%f,%f,%f,%f,%s",
			csvFileRecord.SerialNumber,csvFileRecord.IMEI,csvFileRecord.TESTTIME,csvFileRecord.StationName,csvFileRecord.SpecFileName,csvFileRecord.SpecFileVer,"",
			GSM900TestData.PowerAvg,GSM900TestData.PeakPhaseErrorAvg,GSM900TestData.RMSPhaseErrorAvg,
			PCN1800TestData.PowerAvg,PCN1800TestData.PeakPhaseErrorAvg,PCN1800TestData.RMSPhaseErrorAvg,"\n");
	
	//fclose(fp);
	return 0;
}



int SaveTestResults()
{
	FILE * fpCSV;
	fpCSV=OpenCSVLogFile(fpCSV);
	AddCSVFileRecord(fpCSV);
	fclose(fpCSV);
	return 0;
}

int ReadSpec()
{
	FILE *stream;
	int i,j,ret;
	char tempstr[BUFFERLENGTH]; 
	if((stream=fopen(SPEC_FILE_NAME,"r"))==NULL)
		printf("The \"AT.spe\" is not opened!" );
	else
		{
			for (i=0;i<SPESTRLINES;i++)
				{
					fscanf(stream,"%s",tempstr);
				}
			//GSM900 SpecData
			ret=fscanf(stream,"%s\n%d,%d",tempstr,&GSM900SpecData.PowerAvgH,&GSM900SpecData.PowerAvgL);
			ret=fscanf(stream,"%s\n%d,%d",tempstr,&GSM900SpecData.PeakPhaseErrorH,&GSM900SpecData.PeakPhaseErrorL);
			ret=fscanf(stream,"%s\n%d,%d",tempstr,&GSM900SpecData.RMSPhaseErrorH,&GSM900SpecData.RMSPhaseErrorL);

			for (i=0;i<SPESTRLINES2;i++)
				{
					fscanf(stream,"%s",tempstr);
				}
			//PCN1800 SpecData
			ret=fscanf(stream,"%s\n%d,%d",tempstr,&PCN1800SpecData.PowerAvgH,&PCN1800SpecData.PowerAvgL);
			ret=fscanf(stream,"%s\n%d,%d",tempstr,&PCN1800SpecData.PeakPhaseErrorH,&PCN1800SpecData.PeakPhaseErrorL);
			ret=fscanf(stream,"%s\n%d,%d",tempstr,&PCN1800SpecData.RMSPhaseErrorH,&PCN1800SpecData.RMSPhaseErrorL);			
			fclose(stream);
		}
	return 0;
}

int MeasResultEvaluate(struct SpecData* specdata,struct TestData *testdata,struct TestResult *testresult)
{	
	int flag;
	flag=PASS;
	if(testdata->PowerAvg>specdata->PowerAvgH||testdata->PowerAvg<specdata->PowerAvgL)
	{
		testresult->PowerAvg=FAIL;
		flag=FAIL;
	}
	if(testdata->PeakPhaseErrorAvg>specdata->PeakPhaseErrorH||testdata->PeakPhaseErrorAvg<specdata->PeakPhaseErrorL)
	{
		testresult->PeakPhaseErrorAvg=FAIL;
		flag=FAIL;
	}
	if(testdata->RMSPhaseErrorAvg>specdata->RMSPhaseErrorH||testdata->RMSPhaseErrorAvg<specdata->RMSPhaseErrorL)
	{
		testresult->RMSPhaseErrorAvg=FAIL;
		flag=FAIL;
	}
	return flag;
}

int main (int argc, char *argv[])
{	
	if (InitCVIRTE (0, argv, 0) == 0)	/* Needed if linking in external compiler; harmless otherwise */
		return -1;	/* out of memory */
	if ((pnl = LoadPanel (0, "interface.uir", PNL)) < 0)
		return -1;
	DisplayPanel (pnl);
	IniErrorString(ErrorString);
	InitIniKey();
	ReadIniFile();
	ReadSpec();	
	ImportNetFuncs();
	ConnectSFIS();
	//NetConnection("frankzheng","dl",iniData.RequestLogDrive);
//	NetConnection(iniData.HostName,iniData.RequestDir,iniData.RequestLogDrive);
	//test SaveTestResults();
	//SaveTestResults();
	RunUserInterface ();
	return 0;
}

int TestMain()
{	
	int i,j;
	int StatusRegister=0;
	int status;
	char SNbuffer[SN_SIZE];
	FILE *fRequest,*fResponse,*fResult;
	//char filename[STRINGLENGTH];
	SetPanelAttribute (pnl, ATTR_BACKCOLOR, VAL_DEFAULT);
	ResetTextBox (pnl, PNL_TEXTBOX_RESULT, "");
	ProcessSystemEvents();

	//get SN
	status = PromptPopup ("SN", "Read SN", SNbuffer,SN_SIZE-1);
	strcpy(GSM900TestData.SN,SNbuffer);
	strcpy(PCN1800TestData.SN,GSM900TestData.SN);
	SetCtrlVal (pnl, PNL_STRING_4, SNbuffer);
	//Check SN

	WriteRequestFile();
	if(CheckResponseFile())
		{
			errorCode=Read_Response_File_Error;
			ErrorReport(errorCode,ErrorString);
			return 1;
		}
		
	
	comport=COM1;
			 
	RS232Error=OpenComConfig (comport, "", BAUDRATE, 0, 8, 1, IO_QUEUE_SIZE, IO_QUEUE_SIZE);
	SetCTSMode (comport, LWRS_HWHANDSHAKE_CTS_RTS);
	
	strcpy(buffer,"*cls\n");
	bytewrite=ComWrt (comport, buffer, strlen(buffer));
	
//GSM900/GSM1800
	// strcpy(buffer,"conf:syst gsm900,gsm1800\n");
	strcpy(buffer,"conf:syst GSMPCN\n");
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 

//Config to BCH+TCH Mode
	strcpy(buffer,"CONF:GSM900:BS:CCH:ARFC 30\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 
	strcpy(buffer,"CONF:GSM900:BS:TCH:ARFC 62\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 

//Antenna Parameters check
//CONFigure:<system>:PATTenuation:LEVel <RX>, <TX>
	strcpy(buffer,"CONF:GSM900:PATT:LEV 9,8\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 

//Average Power(62,5)
	strcpy(buffer,"conf:gsm:ms:tch:plev 5\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 
/*
FlushInQ (comport);	
Inqlength = GetInQLen (comport);
ComRd (comport, buffer, Inqlength);
sscanf(buffer,"%d",&StatusRegister);
*/

//Turn on the MS
	SetCtrlVal (pnl, PNL_TEXTMSG, STR_TURN_ON_MS);
	ProcessSystemEvents();
	//Delay(MAX_POWERUP_TIME); 

	strcpy(buffer,"CALL:BSOR\n");                
	bytewrite=ComWrt (comport, buffer, strlen(buffer));
/*
			FlushInQ (comport);
			strcpy(buffer,"STAT:OPER:SIGN?\n");                
			bytewrite=ComWrt (comport, buffer, strlen(buffer));
			Delay(30);
			Inqlength = GetInQLen (comport);
			strcpy(buffer,""); 
			strcpy(buffer,"STAT:OPER:SIGN?\n");
			ComRd (comport, buffer, Inqlength);
			sscanf(buffer,"%d",&StatusRegister);
*/
	for (i=0;i<MAX_CALLCONNECT_TIME/DELAY;i++)
		{
			FlushInQ (comport);
			strcpy(buffer,"STAT:OPER:SIGN?\n");                
			bytewrite=ComWrt (comport, buffer, strlen(buffer));
			for (j=0;j<MAX_TIME_WAIT_REG/DELAY;j++)
				{
					Delay(DELAY);
					Inqlength = GetInQLen (comport);
					if(Inqlength==SIG_REG_SIZE)
						{
							ComRd (comport, buffer, Inqlength);
							sscanf(buffer,"%d",&StatusRegister);
							break;
						}
				}
			if(StatusRegister==REG_CALL_ACTIVE)
				{
					break;
				}
				
		}	

/*
	for (i=0;i<MAX_CALLCONNECT_TIME;i++)
		{
			FlushInQ (comport);
			strcpy(buffer,"STAT:OPER:SIGN?\n");                
			bytewrite=ComWrt (comport, buffer, strlen(buffer));
			Delay(DELAY);
			Inqlength = GetInQLen (comport);
			if(Inqlength!=0)
				{
					ComRd (comport, buffer, Inqlength);
					sscanf(buffer,"%d",&StatusRegister);
					if(StatusRegister==64)
						{
							break;
						}
				}
				
		}	
	*/
	FlushInQ (comport);
	//Delay(MAX_CALLCONNECT_TIME);
	
//Average Power		
	SetCtrlVal (pnl, PNL_TEXTMSG, "GSM900 Testing...");  
	ProcessSystemEvents();
	strcpy(buffer,"MEAS:ARR:RFTR:GRO:ALL:MAV? 10\n");                        
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 
	FlushInQ (comport); 
	strcpy(buffer,"");
	for (i=0;i<IO_QUEUE_SIZE;i++)
		{
			buffer[i]='\0';
		}
	for(i=0;i<MAX_MEAS_TIME/DELAY;i++)
		{
			Delay(DELAY);
			Inqlength = GetInQLen (comport);
			if(Inqlength!=0&&Inqlength==TEST_DATA_SIZE)//if(Inqlength!=0)				
				{
					//Delay(DELAY);
					break;
				}
		}
	ComRd (comport, buffer, Inqlength);  //?
	ResetTestData(&GSM900TestData);
	ResetTestResult(&GSM900TestResult);
	sscanf(buffer,"%e,%e,%e,%e,%e",&GSM900TestData.PeakPhaseErrorAvg,
								   &GSM900TestData.RMSPhaseErrorAvg,
								   &GSM900TestData.FrequencyErrorAvg,
								   &GSM900TestData.BurstLengthAvg,
								   &GSM900TestData.PowerAvg);
	FlushInQ (comport);
//PCN1800 
	strcpy(buffer,"CONF:GSM1800:BS:TCH:ARFC 698\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer));

	strcpy(buffer,"conf:gsm1800:ms:tch:plev 0\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 

//Antenna Parameters check
//CONFigure:<system>:PATTenuation:LEVel <RX>, <TX>
//	strcpy(buffer,"CONF:GSM900:PATT:LEV 17,17\n"); 
//	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 
	SetCtrlVal (pnl, PNL_TEXTMSG, "GSM1800 Testing...");
	ProcessSystemEvents();
	strcpy(buffer,"MEAS:ARR:RFTR:GRO:ALL:MAV? 10\n");                        
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 
	//FlushInQ (comport); 
	for(i=0;i<MAX_MEAS_TIME/DELAY;i++)
		{
			Delay(DELAY);
			Inqlength = GetInQLen (comport);
			if(Inqlength!=0)
				{
					//Delay(DELAY);
					break;
				}
		}
	ComRd (comport, buffer, Inqlength);  //?
	ResetTestData(&PCN1800TestData);
	ResetTestResult(&PCN1800TestResult);
	sscanf(buffer,"%e,%e,%e,%e,%e",&PCN1800TestData.PeakPhaseErrorAvg,
								   &PCN1800TestData.RMSPhaseErrorAvg,
								   &PCN1800TestData.FrequencyErrorAvg,
								   &PCN1800TestData.BurstLengthAvg,
								   &PCN1800TestData.PowerAvg);
	SetCtrlVal (pnl, PNL_TEXTMSG, "Tests Finished!");
	ProcessSystemEvents();
	strcpy(buffer,"CALL:BSR\n");                 
	bytewrite=ComWrt (comport, buffer, strlen(buffer));
	
	if((MeasResultEvaluate(&GSM900SpecData,&GSM900TestData,&GSM900TestResult)==FAIL)
		||(MeasResultEvaluate(&PCN1800SpecData,&PCN1800TestData,&PCN1800TestResult)==FAIL))
		{
		//Fail report
		SetPanelAttribute (pnl, ATTR_BACKCOLOR, VAL_RED);
		SetCtrlAttribute (pnl, PNL_TEXTBOX_RESULT, ATTR_TEXT_COLOR, VAL_RED);
		ResetTextBox (pnl, PNL_TEXTBOX_RESULT, "FAIL");		
		}
		else
			{
				SetCtrlAttribute (pnl, PNL_TEXTBOX_RESULT, ATTR_TEXT_COLOR, VAL_GREEN);
				ResetTextBox (pnl, PNL_TEXTBOX_RESULT, "PASS");	
			}
//	SetPanelAttribute (pnl, ATTR_BACKCOLOR, VAL_RED);
//	GetPanelAttribute (pnl, ATTR_BACKCOLOR, &BackColor);
//	ResetTextBox (pnl, PNL_TEXTBOX_RESULT, "FAIL"); 


//Switch to DCS1800/PCN test mode
	strcpy(buffer,"conf:syst PCN\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer)); 
	
	//End
	strcpy(buffer,"SYST:COMM:LOC\n"); 
	bytewrite=ComWrt (comport, buffer, strlen(buffer));

	RS232Error=CloseCom (comport);

	SaveTestResults();
	return 0;
}


int CVICALLBACK CALLBACK_Start (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	
	switch (event)
		{
		case EVENT_COMMIT:
			//ResetTestData();
			SetCtrlAttribute (pnl, PNL_Start, ATTR_DIMMED, 1);
			ProcessSystemEvents();
			
			TestMain();
			SetCtrlAttribute (pnl, PNL_Start, ATTR_DIMMED, 0);
			ProcessSystemEvents();
			
			break;
		case EVENT_RIGHT_CLICK:

			break;
		}
	return 0;
}

int CVICALLBACK Time (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	char strTime[SYSTEM_TIME_STRING_SIZE];
	int status;
	switch (event)
		{
		case EVENT_TIMER_TICK:
			status = GetSystemTime (&SystemTime.hour,&SystemTime.minute,&SystemTime.second);
			strTime[0]=SystemTime.hour/10+48;
			strTime[1]=SystemTime.hour-(SystemTime.hour/10)*10+48;
			strTime[3]=SystemTime.minute/10+48;
			strTime[4]=SystemTime.minute-(SystemTime.minute/10)*10+48;
			strTime[6]=SystemTime.second/10+48;
			strTime[7]=SystemTime.second-(SystemTime.second/10)*10+48;
			strTime[8]='\0';
			strTime[2]=':';
			strTime[5]=':';    
			
			SetCtrlVal (pnl, PNL_NOWTIME, strTime);
			ProcessSystemEvents();
			break;
		}
	return 0;
}
																	   

void CVICALLBACK FileOpen (int menuBar, int menuItem, void *callbackData,
		int panel)
{
}

void CVICALLBACK Exit (int menuBar, int menuItem, void *callbackData,
		int panel)
{
	QuitUserInterface (0);
}

void CVICALLBACK OpenHistory (int menuBar, int menuItem, void *callbackData,
		int panel)
{
}