📄 cal_dll.cpp
字号:
stat=cal_hs.HS_GetHSCurRamp(band,&parm);
if(stat==FALSE)
{
return HS_COMM_ERROR;
}
for(i=0; i < RAMP_TABLE_SIZE; i++)
{
cal_data.CurAPCDacGsm[i] = parm[i];
}
error=CalInfineonAPC(0.0 /*CoarseTxDelta*/,
cal_data.CurAPCDacGsm,
cal_data.GSMRampTable,
parms.gsm_highest_power,
parms.gsm_ramp_up_length,
parms.gsm_ramp_down_length,
parms.gsm_ramp_up_delta,
parms.gsm_ramp_down_delta,
parms.gsm_pedestal_slope,
parms.gsm_pedestal_power,
parms.gsm_low_power[0],parms.gsm_low_power[1],
parms.gsm_low_slope[0],parms.gsm_low_slope[1]);
if(error!=SUCCESS)
{
return error;
}
error=ramp_sanity_check(cal_data.ComputedAPCDacGsm);
if(error!=SUCCESS)
{
return error;
}
return SUCCESS;
} // end CalTxGSM
//*******************************************************************************
// DCS Tx Cal
Error_t cal::CalTxDcs(UserDefParm_t parms)
{
Int16 RampIndex0;
Int16 RampIndex1;
float RealTxLev[RAMP_TABLE_SIZE];
float ExpectedTxPwr;
float Slope;
float delta_pwr;
Int16 i;
UInt16 new_value;
UInt16 trial_ramp[RAMP_LENGTH];
int pedestal_success;
unsigned stat;
unsigned first_pass;
Parm_t parm;
unsigned pedestal_stat;
float sat_power; // tx power at saturation
unsigned sat_dac; // pk dac value at saturation
float highest_unsat_power; // tx power before saturation
unsigned highest_unsat_dac; // pk dac value before saturation
float tx_power;
unsigned hard_upper_limit;
unsigned hard_lower_limit;
unsigned upper_limit;
unsigned lower_limit;
unsigned peak_dac;
unsigned index0,index1;
float msrd0,msrd1;
float Intercept;
unsigned Step;
Error_t search_stat;
Error_t error;
unsigned fine_step;
// replacement code 9/15/99 nrs
// do the DCS Tx peak power calibration over 3 linear regions
// power levels 0-3, 4-10, and 11-15
// power_level = ramp_index-3 <--> ramp_index = power_level+3
TargetTxPwrValue[DCS][0]=TargetTxPwrValue[DCS][1]=TargetTxPwrValue[DCS][2]=
TargetTxPwrValue[DCS][3]=parms.dcs_highest_power;
// cal_measure.GetRampStatus(FALSE,&pedestal_stat);
// if(pedestal_stat && first_pass==FALSE)
// {
// pedestal_success=TRUE;
// / cal_data.DCSPedestal=i-0x10;;
// break;
// }
// first_pass=FALSE;
// } // end if HP8922
// pedestal has been found coarsely.
// Go back up 32, then down in steps of 4 until success.
stat=cal_hs.HS_GetHSCurRamp(band,&parm);
if(stat==FALSE)
{
return HS_COMM_ERROR;
}
for(i=0; i < RAMP_TABLE_SIZE; i++)
{
cal_data.CurAPCDacDcs[i] = parm[i];
}
error=CalInfineonAPC(0.0 /* coarse tx offset */,
cal_data.CurAPCDacDcs,
cal_data.DCSRampTable,
parms.dcs_highest_power,
parms.dcs_ramp_up_length,
parms.dcs_ramp_down_length,
parms.dcs_ramp_up_delta,
parms.dcs_ramp_down_delta,
parms.dcs_pedestal_slope,
parms.dcs_pedestal_power,
parms.dcs_low_power[0],parms.dcs_low_power[1],
parms.dcs_low_slope[0],parms.dcs_low_slope[1]);
if(error!=SUCCESS)
{
return error;
}
error=ramp_sanity_check(cal_data.ComputedAPCDacDcs);
if(error!=SUCCESS)
{
return error;
}
return SUCCESS;
} // end cal::CalTxDcs
//*******************************************************************************
// PCS Tx Cal
Error_t cal::CalTxPcs(UserDefParm_t parms)
{
Int16 RampIndex0;
Int16 RampIndex1;
float RealTxLev[RAMP_TABLE_SIZE];
float ExpectedTxPwr;
float Slope;
float delta_pwr;
Int16 i;
UInt16 new_value;
UInt16 trial_ramp[RAMP_LENGTH];
int pedestal_success;
unsigned stat;
unsigned first_pass;
Parm_t parm;
unsigned pedestal_stat;
float sat_power; // tx power at saturation
unsigned sat_dac; // pk dac value at saturation
float highest_unsat_power; // tx power before saturation
unsigned highest_unsat_dac; // pk dac value before saturation
float tx_power;
unsigned hard_upper_limit;
unsigned hard_lower_limit;
unsigned upper_limit;
unsigned lower_limit;
unsigned peak_dac;
unsigned index0,index1;
float msrd0,msrd1;
float Intercept;
unsigned Step;
Error_t search_stat;
Error_t error;
unsigned fine_step;
// replacement code 9/15/99 nrs
// do the PCS Tx peak power calibration over 3 linear regions
// power levels 0-3, 4-10, and 11-15
// power_level = ramp_index-3 <--> ramp_index = power_level+3
// get current peak DAC values
TargetTxPwrValue[PCS][0]=TargetTxPwrValue[PCS][1]=TargetTxPwrValue[PCS][2]=
TargetTxPwrValue[PCS][3]=parms.pcs_highest_power;
stat=cal_hs.HS_GetHSCurRamp(band,&parm);
if(stat==FALSE)
{
return HS_COMM_ERROR;
}
for(i=0; i < RAMP_TABLE_SIZE; i++)
{
cal_data.CurAPCDacPcs[i] = parm[i];
}
error=CalInfineonAPC(0.0 /* coarse tx offset */,
cal_data.CurAPCDacPcs,
cal_data.PCSRampTable,
parms.pcs_highest_power,
parms.pcs_ramp_up_length,
parms.pcs_ramp_down_length,
parms.pcs_ramp_up_delta,
parms.pcs_ramp_down_delta,
parms.pcs_pedestal_slope,
parms.pcs_pedestal_power,
parms.pcs_low_power[0],parms.pcs_low_power[1],
parms.pcs_low_slope[0],parms.pcs_low_slope[1]);
if(error!=SUCCESS)
{
return error;
}
error=ramp_sanity_check(cal_data.ComputedAPCDacPcs);
if(error!=SUCCESS)
{
return error;
}
return SUCCESS;
} // end cal::CalTxPcs
Error_t cal::ramp_sanity_check(unsigned peak_dac[])
{
unsigned i;
for(i=0;i<RAMP_TABLE_SIZE;i++)
{
if(i!=0)
{
if(peak_dac[i]>peak_dac[i-1])
{
return PEAK_DAC_NON_MONOTONIC_ERROR;
}
}
if(peak_dac[i]>0x3ff)
{
return PEAK_DAC_RANGE_ERROR;
}
}
return SUCCESS;
}
//*******************************************************************************
//Cal GSM850
Error_t cal::CalTxGsm850(UserDefParm_t parms)
{
Parm_t parm;
UInt16 Step;
UInt16 TestTxRampIndex;
float ExpectedTxPwr;
float RealTxLev[RAMP_TABLE_SIZE];
UInt16 TxRampIndex[RAMP_TABLE_SIZE];
float Slope;
float delta_pwr;
UInt16 new_value;
Int16 i;
UInt16 trial_ramp[RAMP_LENGTH];
UInt16 pedestal_success;
unsigned stat;
unsigned first_pass;
unsigned pedestal_stat;
float tx_power;
float sat_power; // tx power at saturation
unsigned sat_dac; // pk dac value at saturation
float highest_unsat_power; // tx power before saturation
unsigned highest_unsat_dac; // pk dac value before saturation
Error_t error;
unsigned hard_upper_limit;
unsigned hard_lower_limit;
unsigned upper_limit;
unsigned lower_limit;
unsigned peak_dac;
unsigned index0,index1;
float msrd0,msrd1;
float Intercept;
Error_t search_stat;
unsigned fine_step;
// Tx cal - set power level in HS. Measure Tx power - add fudge factor to get HP8922 to
// read correctly - needs to be within 3 dB to read correctly. Calculate the slope (dBm/LSB)
// of the power control DAC transfer function.
// 1. set tx power level to 10 (ramp index = 8). Power s/b 23 dBm
// 2. Set tx power level to 16 (ramp index = 14). Power s/b 11 dBm
// set highest power levels to user parameter
TargetTxPwrValue[GSM850][0]=TargetTxPwrValue[GSM850][1]=TargetTxPwrValue[GSM850][2]=
TargetTxPwrValue[GSM850][3]=parms.gsm850_highest_power;
// get current peak DAC values
stat=cal_hs.HS_GetHSCurRamp(band,&parm);
if(stat==FALSE)
{
return HS_COMM_ERROR;
}
for(i=0; i < RAMP_TABLE_SIZE; i++)
{
cal_data.CurAPCDacGsm850[i] = parm[i];
}
error=CalInfineonAPC(0.0 /*CoarseTxDelta*/,
cal_data.CurAPCDacGsm850,
cal_data.GSM850RampTable,
parms.gsm850_highest_power,
parms.gsm850_ramp_up_length,
parms.gsm850_ramp_down_length,
parms.gsm850_ramp_up_delta,
parms.gsm850_ramp_down_delta,
parms.gsm850_pedestal_slope,
parms.gsm850_pedestal_power,
parms.gsm850_low_power[0],parms.gsm_low_power[1],
parms.gsm850_low_slope[0],parms.gsm_low_slope[1]);
if(error!=SUCCESS)
{
return error;
}
error=ramp_sanity_check(cal_data.ComputedAPCDacGsm850);
if(error!=SUCCESS)
{
return error;
}
return SUCCESS;
} // end CalTxGSM850
//---------------- GSM Rx Calibration
Error_t cal::CalRxGsm()
{
// int rx_cal_pwr[NUMBER_OF_RX_CAL_POINTS]={-94,-88,-72,-56,-40,-24};
int rx_cal_pwr[NUMBER_OF_RX_CAL_POINTS]={-82,-48};
int gsm_gsys_rx_cal_index[NUMBER_OF_RX_CAL_POINTS];
int gsm_gsys_delta[NUMBER_OF_RX_CAL_POINTS];
Int16 i;
int gsys_34; // value of gsys[band][34]
int x0,x1,y0,y1;
int j;
float slope;
UInt16 Rxlev;
// do the cal at 6 points
// power levels =-94,-88,-72,-56,-40,-24 dBm
//
// agc setting 87 (pwr=-23 dBm) - correct rxlev=87
// agc setting 23 (pwr=-87 dBm) - correct rxlev=23
if(cal_hs.HS_GetHSCurGsys(band,34,&gsys_34)==FALSE)
{
return GSM_GSYS_34_ERROR;
}
for(i=0;i<NUMBER_OF_RX_CAL_POINTS;i++)
{
cal_measure.SetRxPower((float)rx_cal_pwr[i]);
cal_hs.HS_SetStop();
cal_hs.HS_SetRxAgc(110+rx_cal_pwr[i]);
Sleep(100);
cal_hs.HS_SetStart();
Sleep(2000);
cal_hs.HS_GetHSRxlev(&Rxlev);
gsm_gsys_delta[i]=110+rx_cal_pwr[i]-Rxlev;
gsm_gsys_rx_cal_index[i]=34-(16*(110+rx_cal_pwr[i])-gsys_34-1200)/32;
}
// build the correction table
for(i=0;i<NUMBER_OF_RX_CAL_POINTS-1;i++)
{
x0=gsm_gsys_rx_cal_index[i];
x0=min(x0,GSYS_SIZE-1);
x1=gsm_gsys_rx_cal_index[i+1];
x1=min(x1,GSYS_SIZE-1);
y0=gsm_gsys_delta[i];
y1=gsm_gsys_delta[i+1];
slope=(float)(y1-y0)/(float)(x1-x0);
if(x0<0 || x0>GSYS_SIZE || x1 <0 || x1>GSYS_SIZE)
{
return GSM_RXLEV_INDEX_ERROR;
}
for(j=x0;j>x1;j--)
{
cal_data.GSMRxPwrDelta[j]=(int)(16*((float)y0+(slope*(j-x0))));
}
}
// fill in ends of table
for(i=gsm_gsys_rx_cal_index[0];i<GSYS_SIZE;i++)
cal_data.GSMRxPwrDelta[i]=16*gsm_gsys_delta[0];
for(i=0;i<=gsm_gsys_rx_cal_index[NUMBER_OF_RX_CAL_POINTS-1];i++)
cal_data.GSMRxPwrDelta[i]=16*gsm_gsys_delta[NUMBER_OF_RX_CAL_POINTS-1];
// although it would be nice to add the delta to each value in the existing table, it's
// too slow to read each value, add the delta to it, and write it back (don't know if that's
// because of the radio's response time, the serial i/f speed, or the logging of the operations
// to the SIO window). Instead, I'll read the system gain table at the same indices that I
// read the power at and build an interpolated table based on those readings, add the deltas
// and write the whole thing out.
for(i=0;i<NUMBER_OF_RX_CAL_POINTS-1;i++)
{
x0=gsm_gsys_rx_cal_index[i];
x0=min(x0,GSYS_SIZE-1);
x1=gsm_gsys_rx_cal_index[i+1];
x1=min(x1,GSYS_SIZE-1);
if(cal_hs.HS_GetHSCurGsys(band,x0,&y0)==FALSE)
{
return GSYS_ERROR;
}
if(cal_hs.HS_GetHSCurGsys(band,x1,&y1)==FALSE)
{
return GSYS_ERROR;
}
slope=(float)(y1-y0)/(float)(x1-x0);
for(j=x0;j>x1;j--)
{
cal_data.GSMRxPwr[j]=(int)((float)y0+(slope*(float)(j-x0)));
}
}
// fill in ends of interpolated power table
if(cal_hs.HS_GetHSCurGsys(band,gsm_gsys_rx_cal_index[NUMBER_OF_RX_CAL_POINTS-1],&cal_data.GSMRxPwr[gsm_gsys_rx_cal_index[NUMBER_OF_RX_CAL_POINTS-1]])==FALSE)
{
return GSYS_ERROR;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -