measure.cpp

这是一个手机校准程序

// measure.cpp
// (c) Mobilink Telecom Inc, 1999, 2000
//
// May 21, 2000
// Nick Steffen
//
// Contains the measurement object
//
// June 27, 2000
// Added SetCableLoss() & GetCableLoss()
//
// September 20, 2000
// Added different version of GetTxPower()
// It accepts a third parameter which determines whether,
// when the expected power is not within 3 dB of the actual power,
// the search direction is from 33 dBm to 0 dBm or the other direction.
//
// February 9, 2001
// Modified GetUpperRampStatus() to change T0 as a function of band
//
// February 15, 2001
// Modified GetUpperRampStatus() to change -0.5 dB to -0.55, and -7.0 dB to -5.7
//
// March 2, 2001
// Modified to use HP8960
//
// March 5, 2001
// Modified GetTxPower() for 8960 to correctly measure power when expected and actual are different.
//
// March 11, 2001
// Added logging to 8960 clauses.
//

#include "caltypes.h"
#include "decl-32.h"
#include "measure.h"
#include "ramp_status.h"
//#include "visa.h"
#include "age1960.h"


#define		MAX_8922_LOOP_COUNT		20
#define		HP_ERROR_CODE	(-1)
#define   IBDEV_ERROR   (-1)

// Rohde and Schwarz definitions
// secondary address - National Instruments specific
#define   SECONDARY_ADDR    96
// define offsets from that
#define SECONDARY_ADDR_OFFSET_GSM900_NS   1
#define SECONDARY_ADDR_OFFSET_GSM1800_NS  2
#define SECONDARY_ADDR_OFFSET_GSM1900_NS  3
// secondary address definitions for function groups
#define SECONDARY_ADDR_GSM900_NS  (SECONDARY_ADDR+SECONDARY_ADDR_OFFSET_GSM900_NS)
#define SECONDARY_ADDR_GSM1800_NS (SECONDARY_ADDR+SECONDARY_ADDR_OFFSET_GSM1800_NS)
#define SECONDARY_ADDR_GSM1900_NS (SECONDARY_ADDR+SECONDARY_ADDR_OFFSET_GSM1900_NS)



//*******************************************************************************
ViSession measure::GetVISASession()
  {
#if VISA
  return session;
#else
  return 0;
#endif
  }

//*******************************************************************************
ViSession measure::GetVISAInstrument()
  {
#if VISA
  return vi_instr;
#else
  return 0;
#endif
  }

//*******************************************************************************
BOOL measure::SetCableLoss(float loss)
  {
  char buf[256];
  double freq_offset[1];
  double loss_offset[1];
  int offset_items=3;
  int i;
  
  cable_loss=loss;
  loss_offset[0]=cable_loss;
  freq_offset[0]=800000000.0;
  
  if(tester_type==AGT8960)
    {
	  age1960_amplitudeOffset(vi_instr, freq_offset, loss_offset, 1);  // For latest Agilent drivers
	  //age1960_amplitudeOffset(vi_instr, loss);  // For older Agilent drivers
    }
  if(tester_type==HP8922)
    {
// Turn cable loss on
    sprintf(buf,"CONFIGURE:OFLEVEL:MODE 'ON'"); 
    GpibWrt(buf);
  // Set cable loss
    sprintf(buf,"CONFIGURE:OFLEVEL:RFINOUT %f",loss_offset[0]); 
    GpibWrt(buf);
    }


  else if(tester_type==CM200)
    {
    if(band==GSM)
      {
      sprintf(buf,"SENSE:CORRECTION:LOSS:INPUT2 %f",-1.0*cable_loss);
      GpibWrt(IdCM200_GSM900_NS,buf);
      sprintf(buf,"SENSE:CORRECTION:LOSS:OUTPUT2 %f",-1.0*cable_loss);
      GpibWrt(IdCM200_GSM900_NS,buf);
      }
    else if(band==DCS)
      {
      sprintf(buf,"SENSE:CORRECTION:LOSS:INPUT2 %f",-1.0*cable_loss);
      GpibWrt(IdCM200_GSM1800_NS,buf);
      sprintf(buf,"SENSE:CORRECTION:LOSS:OUTPUT2 %f",-1.0*cable_loss);
      GpibWrt(IdCM200_GSM1800_NS,buf);
      }
    else if(band==PCS)
      {
      sprintf(buf,"SENSE:CORRECTION:LOSS:INPUT2 %f",-1.0*cable_loss);
      GpibWrt(IdCM200_GSM1900_NS,buf);
      sprintf(buf,"SENSE:CORRECTION:LOSS:OUTPUT2 %f",-1.0*cable_loss);
      GpibWrt(IdCM200_GSM1900_NS,buf);
      }
    }

  return TRUE;
  }

//*******************************************************************************
BOOL measure::GetCableLoss(float *loss)
  {
  *loss=cable_loss;
  return TRUE;
  }

//*******************************************************************************
void measure::SetLogFilename(char *filename)
  {
  
  strcpy(log_filename,filename);
  }

//*******************************************************************************
void measure::LogGPIB(char *buf)
  {
  HANDLE hFile;
  unsigned long fp;
  unsigned long count;
  char cr[2]={0x0d,0x0a};

  if(logging)
    {
    hFile=CreateFile(log_filename,GENERIC_WRITE,FILE_SHARE_READ,NULL,
                     OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
// go to end of file
    fp=SetFilePointer (hFile,0,NULL, FILE_END); 
    WriteFile(hFile,buf,strlen(buf),&count,NULL);
    WriteFile(hFile,cr,2,&count,NULL); // append a newline
    CloseHandle(hFile);
    }
  }


//*******************************************************************************
void measure::EnableLogging(BOOL enable)
  {
  logging=enable;
  }

//***************
//----------SetGpibAddr()
//***************
BOOL measure::SetGpibAdd(Int8 addr)
  {
  GpibAdd=addr;
  return TRUE;
  }

//***************
//----------SetTesterType()
//***************
BOOL measure::SetTesterType(TesterType_t type)
  {
  if(type==AGT8960)
    {
    tester_type=AGT8960;
    return TRUE;
    }
  else if(type==HP8922)
    {
    tester_type=HP8922;
    return TRUE;
    }
  else if(type==CM200)
    {
    tester_type=CM200;
    return TRUE;
    }
  else return FALSE;
  }

//***************
//----------GetTesterType()
//***************
TesterType_t measure::GetTesterType()
  {
  return tester_type;
  }

//***************
//----------SetChannel(unsigned)
//***************
BOOL measure::SetChannel(unsigned ch)
  {
  channel=ch;
  return TRUE;
  }

//***************
//----------SetBand(BandIndex_t)
//***************
BOOL measure::SetBand(BandIndex_t b)
  {
  band=b;
  return TRUE;
  }

//***************
//----------Disconnect()
// returns FALSE on error
//***************
BOOL measure::Disconnect() 
  {
#if VISA
  viClose(vi_instr);
 // Sleep(100);
  viClose(session);
 // Sleep(100);
#endif
  return TRUE;
  }

//***************
//----------Connect()
// returns FALSE on error
//***************
BOOL measure::Connect() 
  {	
	short	result;
	double power = 0;
  char command[256];
  char buf[256];
  ViStatus viStat;
  ViSession vi;
  char log_msg[256];
   int i;
	if(tester_type==AGT8960)
    {
    sprintf(buf,"GPIB::%d::INSTR",GpibAdd);
    viStat = age1960_init(buf, VI_TRUE, VI_TRUE, &vi);
    if((viStat < VI_SUCCESS) || ( vi == VI_NULL ))
      {
      return FALSE;
      }

        vi_instr = vi;
		viClear(vi_instr);
		age1960_dcl(vi_instr);
		age1960_reset(vi_instr);
		//Sleep(10000);
		age1960_timeOut(vi_instr, 15000);
		//age1960_cmd(vi_instr, "SYST:COMM:GPIB:DEB:STAT ON");
		age1960_cmd(vi_instr, "DISP:MODE TRACK");
		age1960_operatingMode(vi_instr, age1960_TEST_MODE);
		age1960_measurementTimeout(vi_instr, age1960_PFER, 5.0, VI_TRUE);
		age1960_measurementTimeout(vi_instr, age1960_TXPOWER, 0.1, VI_TRUE);
		age1960_measurementTimeout(vi_instr, age1960_PVTIME, 1.0, VI_TRUE);
		age1960_confTXPower(vi_instr, 0, age1960_TRIG_RF_RISE, 0.0, VI_FALSE, 0.1);
		return TRUE;
    }
  else if(tester_type==HP8922)
    {
#if VISA
	//viClose(vi_instr);
    //viClose(session);
    if(viOpenDefaultRM(&session)!=VI_SUCCESS)
      {
      return FALSE;
      }
    sprintf(buf,"GPIB::%d::INSTR",GpibAdd);
    viStat=viOpen (session, buf, VI_NULL, VI_NULL, &vi_instr);
	Sleep(1000);
    if(viStat<VI_SUCCESS)
      {
      return FALSE;
      }
    viClear(vi_instr);
#else // not VISA
    IdHP8922 = ibdev(0, GpibAdd, 0, T1s, 1, 0);					// Locate the IdHP8922
	  if (IdHP8922 == HP_ERROR_CODE)
      {
	    return FALSE;
      }

//Check if HP8922 is connected
	  ibln(IdHP8922, GpibAdd, 0,&result);
	  if( result == 0 )
      {
	    return FALSE;
      }
	  ibclr(IdHP8922);
#endif
    GpibWrt("*RST");
	  Sleep(10000);
	
	  GpibWrt("DISPLAY:SCREEN CELL1");
	  GpibWrt("CELL:MODE 'TEST MODE'");

	  return TRUE;
    }
  else if(tester_type==CM200)
    {

#if VISA //weidg
	  vi_instr=1;
	 // session=256;
	 // Sleep(100);
	  viClear(vi_instr);
	  Sleep(100);
	  viClose(vi_instr);
	  Sleep(100);
   //   viClose(session);
      
		//
	   IdCM200_BASE=0;
	   i=0;
	   viStat=-1;
	  while ((viStat < VI_SUCCESS) && (i<=5))
    
	   {
		  Sleep(100);
		  viStat = viOpenDefaultRM(&session);

		  if (viStat < VI_SUCCESS)
		  { 
			viClose (session);
			Sleep(500);
		  } 
		  i++;
	   }

	   if(viStat<VI_SUCCESS)
	   { 
         return FALSE;
       }
       i=0;
       viStat=-1;
	   while ((viStat < VI_SUCCESS) && (i<=5))
	   {
	      Sleep(500);
		  sprintf(buf,"GPIB::%d::%d::INSTR",GpibAdd,IdCM200_BASE);
		  viStat=viOpen (session, buf, VI_NULL, VI_NULL, &vi_instr);
		  Sleep(1500);
		  if(viStat<VI_SUCCESS)
		  {
		    viClose (vi_instr);
		 	Sleep(500);
		  } 
		  i++;
	   }

	   if(viStat<VI_SUCCESS)
	   { 
         return FALSE;
	   } 	        
		viClear(vi_instr);
		Sleep(500);
   #else    //weidg
    // get the base handle
    IdCM200_BASE = ibdev(0, GpibAdd, SECONDARY_ADDR, 10, 1, 0);					// Locate the CMU200
    if(IdCM200_BASE==IBDEV_ERROR)
      {
      return FALSE;
      }
     // anybody there?
	  ibln(IdCM200_BASE, GpibAdd, SECONDARY_ADDR,&result);
	  if(result==0)
      {
      return FALSE;
      }
   #endif //weidg

   GpibWrt(IdCM200_BASE,"*RST");
   Sleep(4000);

   GpibWrt(IdCM200_BASE,"*OPC?");
   GpibRd(buf);

   Sleep(1000);
// set the secondary addresses
 //   added by weidg
    sprintf(command,"SYST:REM:ADDR:SEC 1,'GSM900MS_NSig'"); //\"");
    GpibWrt(IdCM200_BASE,command);
  //  GpibWrt(IdCM200_BASE,"*OPC?");
  // GpibRd(buf);
    sprintf(command,"SYST:REM:ADDR:SEC 2,'GSM1800MS_NSig'");  //\"",SECONDARY_ADDR_OFFSET_GSM1800_NS);
    GpibWrt(IdCM200_BASE,command);
//	GpibWrt(IdCM200_BASE,"*OPC?");
 //  GpibRd(buf);
    sprintf(command,"SYST:REM:ADDR:SEC 3,'GSM1900MS_NSig'"); //  ;
    GpibWrt(IdCM200_BASE,command);
//	GpibWrt(IdCM200_BASE,"*OPC?");
   // GpibRd(buf);
    sprintf(command,"SYST:REM:ADDR:SEC 4,'RF_NSig'"); //  ;weidg
    GpibWrt(IdCM200_BASE,command); 
	GpibWrt(IdCM200_BASE,"*OPC?");
    GpibRd(buf);

  // get the handles for the function groups
  #if VISA  //weidg
   IdCM200_GSM900_NS=1;
   IdCM200_GSM1800_NS=2;
   IdCM200_GSM1900_NS=3;
   IdCM200_RF_NS=4;    //weidg

  #else     //weidg 
    IdCM200_GSM900_NS=ibdev(0,GpibAdd,SECONDARY_ADDR_GSM900_NS,10,1,0);
    if(IdCM200_GSM900_NS==IBDEV_ERROR)
      {
      return FALSE;
      }
	  ibln(IdCM200_GSM900_NS, GpibAdd, SECONDARY_ADDR_GSM900_NS, &result);
	  if(result==0)
      {
      return FALSE;
      }

    IdCM200_GSM1800_NS=ibdev(0,GpibAdd,SECONDARY_ADDR_GSM1800_NS,10,1,0);
    if(IdCM200_GSM1800_NS==IBDEV_ERROR)
      {
      return FALSE;
      }
	  ibln(IdCM200_GSM1800_NS, GpibAdd, SECONDARY_ADDR_GSM1800_NS, &result);
	  if(result==0)
      {
      return FALSE;
      }


    IdCM200_GSM1900_NS=ibdev(0,GpibAdd,SECONDARY_ADDR_GSM1900_NS,10,1,0);
    if(IdCM200_GSM1900_NS==IBDEV_ERROR)
      {
      return FALSE;
      }
	  ibln(IdCM200_GSM1900_NS, GpibAdd, SECONDARY_ADDR_GSM1900_NS, &result);
	  if(result==0)
      {
      return FALSE;
      }
  #endif    //weidg  

	  }
  return TRUE;
  }



//***************
//------------- SetupInstrument()
//***************
BOOL measure::SetupInstrument()
  {
  char buf[256];
  char buf0[256];
  char buf1[256];
  double freq_offset[1];
  double loss_offset[1];
  int i;

  loss_offset[0]=cable_loss;
  freq_offset[0]=800000000.0;

	if(tester_type==AGT8960)
    {
//------------------- AGT8960

		switch(band)
      {
			case GSM:
        {
        age1960_cellBand(vi_instr, age1960_CELL_1, age1960_PGSM_BAND);
				break;
        }
			case DCS:
        {
        age1960_cellBand(vi_instr, age1960_CELL_1, age1960_DCS1800_BAND);
				break;
        }
			case PCS:
        {
        age1960_cellBand(vi_instr, age1960_CELL_1, age1960_PCS1900_BAND);
				break;
        }
			case GSM850:
		{
		age1960_cellBand(vi_instr, age1960_CELL_1, age1960_GSM850_BAND);
				break;
		}
			default: break;
      } // end switch