cal_inf_apc_1.cpp

这是一个手机校准程序

// put in values for end of table (low power)
// use user-entered slopes to calculate the dac (x) values
    measured[number_of_points-2]=next_lowest_power;
    x[number_of_points-2]=next_lowest_slope*(measured[number_of_points-2]-measured[number_of_points-3])+x[number_of_points-3];
    measured[number_of_points-1]=lowest_power;
    x[number_of_points-1]=lowest_slope*(measured[number_of_points-1]-measured[number_of_points-2])+x[number_of_points-2];

// !!added just for test to build a new canonical ramp
/*    build_infineon_trial_ramp(trial_ramp,TargetTxPwr[GSM][3],
                              13,40,13,73,0,
                              number_of_points,x,measured);
*/
    
// added in version 6.28 for calculating pedestal values
// build a ramp for power level 15 (index 18)
    
// initialize pedestal ramp limits
// m0 = -1 usec, -0.55 dB, lower limit
	m[0].time=-1.0e-6;
    m[0].power=-0.55;
    m[0].llimit=1;
    m[0].ulimit=0;
// m1 = -10 usec, -5.7 dB, upper limit
    m[1].time=-10.0e-6;
    m[1].power=-5.7;
    m[1].llimit=0;
    m[1].ulimit=1;
// m2 = -18 usec, -33 dB, upper limit
    m[2].time=-18.0e-6;
//    m[2].power=-33.0;
    m[2].power=-30.0;
    m[2].llimit=0;
    m[2].ulimit=1;
// 3 points
    num_msmnt_pts=3;
	current_ramp=18;
	up_length=ramp_up_length[15];
    down_length=ramp_down_length[15];
    up_delta=ramp_up_delta[15];
    down_delta=ramp_down_delta[15];
    pedestal_slope=ramp_pedestal_slope[15];
    pedestal_power=ramp_pedestal_power[15];
    low_power_pedestal=pedestal_slope*(pedestal_power-measured[number_of_points-3])+x[number_of_points-3];
    cal_measure.GetUpperRampStatus((unsigned)TRUE,TargetTxPwr[PCS][current_ramp],num_msmnt_pts,m);
    
	count=0;
    pedestal_done=FALSE;
    too_low=too_high=0;
    pedestal_step=COARSE_PEDESTAL_STEP;
	while(!pedestal_done)
	{
		if(too_low && too_high)
        {
			pedestal_step=FINE_PEDESTAL_STEP;
        }
		build_infineon_trial_ramp(trial_ramp,TargetTxPwr[PCS][current_ramp],
									up_length,up_delta,down_length,down_delta,low_power_pedestal,
									number_of_points,x,measured);
		cal_hs.HS_SetRamp(trial_ramp);
		cal_measure.GetUpperRampStatus((unsigned)FALSE,TargetTxPwr[PCS][current_ramp],num_msmnt_pts,m);
		count++;
		if(m[0].passed && m[1].passed && m[2].passed)
	        pedestal_done=TRUE;
		if(count>MAX_INFINEON_PEDESTAL_TRIALS)
        {
			pedestal_done=FALSE;
			break;
        }
		if(!m[0].passed && !m[1].passed && !m[2].passed)  // failed either low and the high limit
	        break;
		else if(!m[2].passed || !m[1].passed)	//upper limit check
        {
			low_power_pedestal-=pedestal_step;
			too_high=1;
//			if(count>20)
//			{
//			    ramp_up_delta[15]++;
//				up_delta++;
//			}
//			if(count>20 && !m[1].passed)
//			{
//				ramp_up_length[15]++;
//				up_length++;
//			}
        }
		else if(!m[0].passed)	//lower limit check
        {
			low_power_pedestal+=pedestal_step;
			too_low=1;
//			if(count>20)
//			{
//				ramp_up_length[15]--;
//				up_length--;
//			}
        }
	}
    if(!pedestal_done)
	{
		return INFINEON_PEDESTAL_ERROR;
	}

// added in version 6.44 for calculating pedestal values
// build a ramp for power level 5 (index 8) )changed to level 5, index 8 on 3/30/01
    
// initialize pedestal ramp limits
// m0 = -1 usec, -0.55 dB, lower limit
    m[0].time=-1.0e-6;
    m[0].power=-0.55;
    m[0].llimit=1;
    m[0].ulimit=0;
// m1 = -18 usec, -41 dB, lower limit
    m[1].time=-18.0e-6;
    m[1].power=-42.0;
    m[1].llimit=1;
    m[1].ulimit=0;
// m2 = -18 usec, -36 dB, upper limit
    m[2].time=-18.0e-6;
    m[2].power=-33.0;
    m[2].llimit=0;
    m[2].ulimit=1;
// 3 points
	num_msmnt_pts=3;
	up_length=ramp_up_length[5];
    down_length=ramp_down_length[5];
    up_delta=ramp_up_delta[5];
    down_delta=ramp_down_delta[5];
    pedestal_slope=ramp_pedestal_slope[5];
    pedestal_power=ramp_pedestal_power[5];
    high_power_pedestal=low_power_pedestal;
    cal_measure.GetUpperRampStatus((unsigned)TRUE,TargetTxPwr[PCS][8],num_msmnt_pts,m);
    
	initial_up_length=up_length;

	count=0;
    pedestal_done=FALSE;
    too_low=too_high=0;
    pedestal_step=COARSE_PEDESTAL_STEP;
    while(!pedestal_done)
	{
		if(too_low && too_high)
		{
			pedestal_step=FINE_PEDESTAL_STEP;
        }
		build_infineon_trial_ramp(trial_ramp,TargetTxPwr[PCS][8],
									up_length,up_delta,down_length,down_delta,high_power_pedestal,
									number_of_points,x,measured);
		cal_hs.HS_SetRamp(trial_ramp);
		cal_measure.GetUpperRampStatus((unsigned)FALSE,TargetTxPwr[PCS][8],num_msmnt_pts,m);
		count++;
		if(m[0].passed && m[1].passed && m[2].passed)
        {
			pedestal_done=TRUE;
        }
		if(count>MAX_INFINEON_PEDESTAL_TRIALS)
        {
			pedestal_done=FALSE;
			break;
        }
		if(!m[0].passed && !m[1].passed && !m[2].passed)  // failed either low and the high limit
        {
			break;
        }
		else if(!m[2].passed)
        {
			high_power_pedestal-=pedestal_step;
			too_high=1;
//			if(count>20)
//			{
//			    ramp_up_delta[15]++;
//				up_delta++;
//			}
        }
		else if(!m[0].passed || !m[1].passed)
        {
			high_power_pedestal+=pedestal_step;
			too_low=1;
//			if(count>20)
//			{
//				ramp_up_length[15]--;
//				up_length--;
//			}
        }
	}
    if(!pedestal_done)
	{
		return INFINEON_PEDESTAL_ERROR;
	}

	for(i=0;i<RAMP_TABLE_SIZE;i++)
	{
		if(i<3)
        {
			up_length=ramp_up_length[0];
			down_length=ramp_down_length[0];
			up_delta=ramp_up_delta[0];
			down_delta=ramp_down_delta[0];
        }
		else
        {
			up_length=ramp_up_length[i-PCS_STARTING_RAMP_INDEX];
			down_length=ramp_down_length[i-PCS_STARTING_RAMP_INDEX];
			up_delta=ramp_up_delta[i-PCS_STARTING_RAMP_INDEX];
			down_delta=ramp_down_delta[i-PCS_STARTING_RAMP_INDEX];
        }
		for(j=0;j<NUMBER_OF_RAMP_POINTS;j++)
        {
			if(j>up_length-1)
			{
				factor=1.0;
			}
			else
			{
				factor=1-cos((PI*j)/(2*up_length-2))*cos((PI*j)/(2*up_length-2));
			}


/*			if(i<=5)
			{
				if (j==7)
					factor=factor-.03;
				if (j==8)
					factor=factor-.125;
			}
*/
			if(i==6 && j==8)
			{
					factor=factor-.03;
			}
			
//			if (i==8 || i==9 || i==10)
			if (i==9 || i==10 || i==11)
			{
				if (j==5 && j==6)
					factor=factor+.2;
				if (j==7)
					factor=factor+.05;
				if (j==9)
					factor=factor-.1;
				if (j==10)
					factor=factor-.12;
			}

			if(i>=11 && i<=14)
			{
				if(j==12)
					factor=factor-.05;
			}


			if (i==17 || i==18)
			{
//				if (j==11 || j==12)
//					factor=factor+0.01;
				if (j>=9 && j<=14)
					factor=factor+0.015;
//				if (j==13)
//					factor=factor+0.005;
			}
			
			power=TargetTxPwr[PCS][i]-up_delta+factor*up_delta;
			dac_code=interpolate(power,x,measured,number_of_points,&error);
			if(error==INTERPOLATION_FAILURE)
			{
				dac_code=extrapolate(power,x,measured,number_of_points,&error);
				if(error==EXTRAPOLATION_FAILURE)
			    {
					return error;
				}
			}
			if(dac_code>0x3ff && power>0)
			{
				return APC_DAC_CODE_TOO_LARGE;
			}
			if(dac_code>0x3ff && power<0)
			{
				dac_code=0;
			}
			if (i<=6)
			{
				if(dac_code<high_power_pedestal)
				{
					dac_code=high_power_pedestal+40;
				}
			}
			else if(i<=10 && i>6) // reduce pedestal for power levels <= 7 (index <= 10)
			{
				if(dac_code<high_power_pedestal)
			    {
					dac_code=high_power_pedestal;
				}
			}
// v 6.58 uses larger of high and low pedestal for low power ramps
			else // i>10 - low power ramps
			{
				if(dac_code<low_power_pedestal)
				{
					dac_code=low_power_pedestal;
			  }
			}
			ramp_table[j][2*i]=dac_code;      // ramp up
		} // for all ramp up points within a power level

	if(i<=6)
	{
		ramp_table[0][2*i]=high_power_pedestal+40;
	}
	else if(i<=10 && i>6)
	{
		ramp_table[0][2*i]=high_power_pedestal;
	}
	else
	{
		ramp_table[0][2*i]=low_power_pedestal;
	}


	if(i>=11 && i<=13)
	{
		for(j=0;j<4;j++)
		{
			ramp_table[j][2*i]=low_power_pedestal;
		}
	}

	if(i==14 || i==15 || i==16)
		for(j=0;j<6;j++)
		{
			ramp_table[j][2*i]=low_power_pedestal;
		}

// ramp down
	for(j=0;j<NUMBER_OF_RAMP_POINTS;j++)
	{
		if (i >= 0 && i <= 16)
		{
			if ((16-down_length)>0)
				offset = 1;
			else
				offset = 0;
		}
		else if (i>= 16)
				offset = 1;
		else
			offset = 0;

		if(j<=16-down_length-offset)
		{
			factor=0.0;
		}
		else
		{
			if(j<int(down_length-6))
				factor=1-cos((PI*(j+1-(16-down_length-offset)))/(2.1*down_length));
			else
				factor=(1-cos((PI*(j+1-(16-down_length-offset)))/(2*down_length))*cos((PI*(j+1-(16-down_length-offset)))/(2*down_length)));
		}
		if(i>=16 && j<=8)
			factor=factor*1.3;

        power=TargetTxPwr[PCS][i]-factor*down_delta;
        dac_code=interpolate(power,x,measured,number_of_points,&error);
        if(error==INTERPOLATION_FAILURE)
          {
          dac_code=extrapolate(power,x,measured,number_of_points,&error);
          if(error==EXTRAPOLATION_FAILURE)
            {
            return error;
            }
          }
        if(dac_code>0x3ff && power>0)
          {
          return APC_DAC_CODE_TOO_LARGE;
          }
        if(dac_code>0x3ff && power<0)
          {
          dac_code=0;
          }
        ramp_table[j][2*i+1]=dac_code;      // ramp down
        } // for all ramp up points within a power level
      } // for all power levels
    } // end if band==PCS

if(band==GSM850)
{
	hard_lower_limit=0x140;
	hard_upper_limit=0x3ff;

// first, find DAC value that gives highest power
	TargetTxPwr[GSM850][0]=TargetTxPwr[GSM850][1]=TargetTxPwr[GSM850][2]=
	TargetTxPwr[GSM850][3]=highest_power;   
	peak=(float)canonical_gsm850_ramp[15];
	i=GSM850_STARTING_RAMP_INDEX;
	error_scale=gain[i];

	cal_hs.HS_SetTxLev(i);
// Handset needs a while to monitor current received signal power value
	Sleep(300);
	expected_power=TargetTxPwr[band][i] + coarse_tx_delta;
// get measured values
	build_trial_ramp(trial_ramp,peak,band,GSM850_TRIAL_PEDESTAL);
	cal_hs.HS_SetRamp(trial_ramp);
	Sleep(100);
	stat=cal_measure.GetTxPower(expected_power,&msrd,expected_power>15.0);
	if(stat==FALSE)
	{
		return POWER_ERROR;
	}
	num_trials=0;
// initialize the power table
	for(z=0;z<NUMBER_OF_DAC_CODES;z++)
	{
		power_table[z]=UNUSED_DAC;  // mark all locations as being unused so far
		ref_table[z]=UNUSED_DAC;  // mark all locations as being unused so far
	}
// adjust peak DAC value to get correct power
	while(fabs(msrd-TargetTxPwr[band][i])>0.5 && num_trials<MAX_TX_TRIALS)
	{
		peak+=error_scale*(TargetTxPwr[band][i]-msrd);

		if(peak>0x3ff || peak<0)
		{ 
				return APC_DAC_CODE_TOO_LARGE;
		}
		build_trial_ramp(trial_ramp,peak,band,GSM850_TRIAL_PEDESTAL);
		cal_hs.HS_SetRamp(trial_ramp);
		cal_hs.HS_SetStop();
		cal_hs.HS_SetStart();
		Sleep(200);
		stat=cal_measure.GetTxPower(expected_power,&msrd,expected_power>15.0);
		ref_table[(unsigned)(peak+0.5)]=msrd;
		if(stat!=FALSE)
			power_table[(unsigned)(peak+0.5)]=msrd;
		if(stat==FALSE || msrd<(TargetTxPwr[band][18]-2.0))
			return POWER_ERROR;
		num_trials++;

	}
	if(num_trials==MAX_TX_TRIALS)
		return TOO_MANY_TX_TRIALS;

	measured[i-GSM_STARTING_RAMP_INDEX]=msrd;
	x[i-GSM_STARTING_RAMP_INDEX]=(unsigned)(peak+0.5);

// put the high power value in
    power_table[(unsigned)(peak+0.5)]=msrd;
	hard_upper_limit=(unsigned)(peak+0.5);
// now have the highest power and its DAC value
// do binary search for other powers. The limits will be adjusted dynamically    
    
    peak=peak-50.0; // move away from highest power