calapi.cpp

这是一个手机校准程序

					cal_object.cal_measure.Disconnect();
					return;
				}
			}
		}

// calibrate the AFC if not already done in GSM
	if(!CurParm.cal_gsm)
	{
	    UI_SetStatusBarText("Calibrating AFC");
		error=cal_object.CalFreqDac();
		if(report_error(error)==IDNO)
		{
			cal_object.cal_hs.HS_CloseComPort();
			cal_object.cal_measure.Disconnect();
			return;
        }
		if(UI_IsAbort())
		{
			if(UI_Error("User abort.")==IDNO)
			{
				cal_object.cal_hs.HS_CloseComPort();
				cal_object.cal_measure.Disconnect();
				return;
			}
        }
	} // end if GSM was not enabled (so we'll do AFC cal here)

// check frequency and phase error
	UI_SetStatusBarText("Testing phase & freq error");
    error=cal_object.TestFreqPhase();
    if(report_error(error)==IDNO)
      {
		cal_object.cal_hs.HS_CloseComPort();
		cal_object.cal_measure.Disconnect();
		return;
      }
      
// calibrate Tx for DCS
	  UI_SetStatusBarText("Calibrating DCS Tx");
    error=cal_object.CalTxDcs(CurParm);
    if(report_error(error)==IDNO)
      {
      cal_object.cal_hs.HS_CloseComPort();
      cal_object.cal_measure.Disconnect();
      return;
      }
    if(UI_IsAbort())
      {
      if(UI_Error("User abort.")==IDNO)
        {
        cal_object.cal_hs.HS_CloseComPort();
        cal_object.cal_measure.Disconnect();
        return;
        }
      }

// calibrate Rx for DCS
	  if(CurParm.cal_rx)
      {
      UI_SetStatusBarText("Calibrating DCS Rx");
// switch cable loss to Rx value
      cal_object.cal_measure.SetCableLoss(-1.0*CurParm.dcs_rx_cable_loss);
      error=cal_object.CalRxDcs();
      cal_object.cal_measure.Cmu_band_abort();  //weidg
      if(report_error(error)==IDNO)
        {
        cal_object.cal_hs.HS_CloseComPort();
        cal_object.cal_measure.Disconnect();
        return;
        }
      } // end if user chose to perform rx calibration
    if(UI_IsAbort())
      {
      if(UI_Error("User abort.")==IDNO)
        {
        cal_object.cal_hs.HS_CloseComPort();
        cal_object.cal_measure.Disconnect();
        return;
        }
      }
    } // end if DCS calibration is enabled

//-------------- set up for PCS
  if(CurParm.cal_pcs)
    {
	UI_SetStatusBarText("Switching to PCS");
    cal_object.SetBand(PCS);
    cal_object.cal_measure.Cmu_band_connect();	//weidg
    cal_object.cal_measure.SetCableLoss(-1.0*CurParm.pcs_tx_cable_loss);
    cal_object.cal_measure.SetBand(PCS);
    cal_object.cal_measure.SetChannel((unsigned int)CurParm.pcs_test_channel);
    cal_object.cal_measure.SetupInstrument();
// set up phone for PCS
    cal_object.cal_hs.HS_SetBand(PCS);
    cal_object.cal_hs.HS_SetArfcn(CurParm.pcs_test_channel);
// check phone output to make sure it's alive
      {
      float tx_power;
      cal_object.cal_hs.HS_SetTxLev(5);
      cal_object.cal_hs.HS_SetStart();
      if(cal_object.cal_measure.GetTxPower(25,&tx_power)==FALSE)
        {
        if(report_error(POWER_ERROR)==IDNO)
          {
          cal_object.cal_hs.HS_CloseComPort();
          cal_object.cal_measure.Disconnect();
          return;
          }
        }
      }

// calibrate the AFC if not already done in GSM/GSM850 or DCS
    if(!CurParm.cal_gsm && !CurParm.cal_dcs && !CurParm.cal_gsm850)
      {
	    UI_SetStatusBarText("Calibrating AFC");
      error=cal_object.CalFreqDac();
      if(report_error(error)==IDNO)
        {
        cal_object.cal_hs.HS_CloseComPort();
        cal_object.cal_measure.Disconnect();
        return;
        }
      if(UI_IsAbort())
        {
        if(UI_Error("User abort.")==IDNO)
          {
          cal_object.cal_hs.HS_CloseComPort();
          cal_object.cal_measure.Disconnect();
          return;
          }
        }
      } // end if GSM and DCS were not enabled (so we'll do AFC cal here)

// check frequency and phase error
	  UI_SetStatusBarText("Testing phase & freq error");
    error=cal_object.TestFreqPhase();
    if(report_error(error)==IDNO)
      {
      cal_object.cal_hs.HS_CloseComPort();
      cal_object.cal_measure.Disconnect();
      return;
      }
      
// calibrate Tx for PCS
    UI_SetStatusBarText("Calibrating PCS Tx");
    error=cal_object.CalTxPcs(CurParm);
    if(report_error(error)==IDNO)
      {
      cal_object.cal_hs.HS_CloseComPort();
      cal_object.cal_measure.Disconnect();
      return;
      }
    if(UI_IsAbort())
      {
      if(UI_Error("User abort.")==IDNO)
        {
        cal_object.cal_hs.HS_CloseComPort();
        cal_object.cal_measure.Disconnect();
        return;
        }
      }

// calibrate Rx for PCS
	  if(CurParm.cal_rx)
      {
      UI_SetStatusBarText("Calibrating PCS Rx");
// switch cable loss to Rx value
      cal_object.cal_measure.SetCableLoss(-1.0*CurParm.pcs_rx_cable_loss);
      error=cal_object.CalRxPcs();
      cal_object.cal_measure.Cmu_band_abort();  //weidg
      if(report_error(error)==IDNO)
        {
        cal_object.cal_hs.HS_CloseComPort();
        cal_object.cal_measure.Disconnect();
        return;
        }
      }  // end if user choose to perform rx calibration
    } // end if PCS cal was selected
  if(UI_IsAbort())
    {
    if(UI_Error("User abort.")==IDNO)
      {
      cal_object.cal_hs.HS_CloseComPort();
      cal_object.cal_measure.Disconnect();
      return;
      }
    }


// generate calibration file
	UI_SetStatusBarText("Writing output file");
	UI_GetOutputFilename(OutputFilename);
  UI_GetParamTemplateFilename(ParamTemplateFilename);
  error=cal_object.GenReport(OutputFilename,ParamTemplateFilename,CurParm);
  if(report_error(error)==IDNO)
    {
    cal_object.cal_hs.HS_CloseComPort();
    cal_object.cal_measure.Disconnect();
    return;
    }


  if(UI_IsAbort())
    {
    if(UI_Error("User abort.")==IDNO)
      {
      cal_object.cal_hs.HS_CloseComPort();
      cal_object.cal_measure.Disconnect();
      return;
      }
    }

	UI_Msg("Finished Calibration");

//	HS_SetStop();
  UI_SetStatusBarText("Calibration complete");

// since I get an exception on exiting this thread, let it run forever and let the main thread
// take care of killing this off
  cal_object.cal_hs.HS_CloseComPort();
  cal_object.cal_measure.Disconnect();
  }

//******************************************************************************
//
// Function Name:	 
//
// Description:	 
//
// Notes:
//
//*******************************************************************************
void CAL_Init(void)
  {
//	CurParm.gpib_address = INVALID_NUM;
//	CurParm.com_port = INVALID_NUM;
  }


//******************************************************************************
//
// Function Name:	 
//
// Description:	 
//
// Notes:
//
//*******************************************************************************
static Error_t PerRunInit(void)
  {
	UserDefParm_t NewParm;

  UI_SetStatusBarText("Beginning calibration");
	get_parameters_from_registry(&NewParm);

// Set chipset type - need to do this before initializing com port
// because the baud rate for the Diana is 19.2 k
  cal_object.SetPACCalType(UI_GetPACCalType());
  cal_object.cal_hs.HS_SetPACCalType(UI_GetPACCalType());

//open serial port
// open comm port every run
//	if(NewParm.com_port != CurParm.com_port)
//    {
		cal_object.cal_hs.HS_SetComPort((enum port)NewParm.com_port);
    if(!cal_object.cal_hs.HS_InitComPort())
      {
			return COMM_INIT_ERROR;
      }
		CurParm.com_port = NewParm.com_port;
//    }

//Initialize instrument
  cal_object.cal_measure.SetTesterType(UI_GetTesterType());
//  if(NewParm.gpib_address != CurParm.gpib_address)
//    {
		cal_object.cal_measure.SetGpibAdd(NewParm.gpib_address);
    if(!cal_object.cal_measure.Connect())
      {
      return GPIB_INIT_ERROR;
      }
//    }
	
// save the user selected paramters into CurParm structure
	memcpy(&CurParm, &NewParm, sizeof(CurParm));

	//needs to invert cable loss value
/* removed in version 6.38 - inversion occurs in calls to SetCableLoss()
	CurParm.gsm_tx_cable_loss = 0 - CurParm.gsm_tx_cable_loss;
	CurParm.gsm_rx_cable_loss = 0 - CurParm.gsm_rx_cable_loss;
	CurParm.dcs_tx_cable_loss = 0 - CurParm.dcs_tx_cable_loss;
	CurParm.dcs_rx_cable_loss = 0 - CurParm.dcs_rx_cable_loss;
	CurParm.pcs_tx_cable_loss = 0 - CurParm.pcs_tx_cable_loss;
	CurParm.pcs_rx_cable_loss = 0 - CurParm.pcs_rx_cable_loss;
*/
	return SUCCESS;
  }

//*******************************************************************************
// report errors
unsigned report_error(Error_t error)
  {
  if(error==HS_COMM_ERROR)
    {
    return UI_Error("Could not communicate with handset.");
    }
  if(error==GSM_PEDESTAL_ERROR)	        
    {
    return UI_Error("Could not calculate GSM pedestal.");
    }
  if(error==DCS_PEDESTAL_ERROR)
    {
    return UI_Error("Could not calculate DCS pedestal.");
    }
  if(error==PCS_PEDESTAL_ERROR)
    {
    return UI_Error("Could not calculate PCS pedestal.");
    }
  if(error==GSM_RXLEV_INDEX_ERROR)
    {
    return UI_Error("GSM Rx Level Index out of range.");
    }    
  if(error==DCS_RXLEV_INDEX_ERROR)	        
    {
    return UI_Error("DCS Rx Level Index out of range.");
    }
  if(error==PCS_RXLEV_INDEX_ERROR)	        
    {
    return UI_Error("GSM Rx Level Index out of range.");
    }
  if(error==GSM_GSYS_34_ERROR)
    {
    return UI_Error("GSM Gsys[34] out of range.");
    }
  if(error==DCS_GSYS_34_ERROR)		          
    {
    return UI_Error("DCS Gsys[34] out of range.");
    }
  if(error==PCS_GSYS_34_ERROR)		         
    {
    return UI_Error("PCS Gsys[34] out of range.");
    }
  if(error==POWER_ERROR)
    {
    return UI_Error("Could not determine output power.");
    }
  if(error==GSYS_ERROR)
    {
    return UI_Error("Gsys error.");
    }
  if(error==PEAK_DAC_NON_MONOTONIC_ERROR)
    {
    return UI_Error("APC peak DAC values not monotonic.");
    }
  if(error==PEAK_DAC_RANGE_ERROR)
    {
    return UI_Error("APC peak DAC values out of range.");
    }
  if(error==INTERPOLATION_FAILURE)         
    {
    return UI_Error("APC interpolation failure.");
    }
  if(error==PEAK_POWER_TOO_LOW_ERROR)      
    {
    return UI_Error("Peak power too low.");
    }
  if(error==EXTRAPOLATION_FAILURE)
    {
    return UI_Error("APC extrapolation failure.");
    }
  if(error==APC_DAC_CODE_TOO_LARGE)     
    {
    return UI_Error("APC peak DAC values out of range.");
    }
  if(error==MIN_POWER_TOO_LARGE)         
    {
    return UI_Error("Min power too high.");
    }
  if(error==TOO_MANY_TX_TRIALS)         
    {
    return UI_Error("Didn't converge while calibrating Tx power.");
    }
  if(error==FREQ_ERROR)         
    {
    return UI_Error("Frequency error is beyond tolerance.");
    }
  if(error==PHASE_ERROR)         
    {
    return UI_Error("Phase error is beyond tolerance.");
    }
  if(error==INFINEON_PEDESTAL_ERROR)         
    {
    return UI_Error("An error occured while calibrating the pedestal value for the Infineon PAC.");
    }
  if(error==TEMPLATE_FILE_ERROR)         
    {
    return UI_Error("An error occured while opening or reading the parameter template file.");
    }
  if(error==OUTPUT_FILE_ERROR)         
    {
    return UI_Error("An error occured while opening or writing the output system parameter file.");
    }
  if(error==DEFAULT_SYSGAIN_FILE_ERROR)         
    {
    return UI_Error("An error occured while opening or reading the default sysgain file.");
    }
  if(error==OFFSET_ERROR)         
    {
    return UI_Error("An error occured while measure frequency offset.");
    }
  return SUCCESS;
  }