cal_inf_apc_1.cpp

这是一个手机校准程序

    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,SEARCH_DOWN);
    for(i=GSM850_STARTING_RAMP_INDEX+1;i<=GSM850_ENDING_RAMP_INDEX;i++)
	{
		expected_power=TargetTxPwr[band][i] + coarse_tx_delta;
		upper_limit=(unsigned)(peak+0.5); // start from old upper limit
		lower_limit=hard_lower_limit;
		num_trials=0;
		search=0;
		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(100);
		stat=cal_measure.GetTxPower(expected_power,&msrd);
		
		for(z=hard_upper_limit;z>hard_lower_limit;z--)
		{
			if(fabs(ref_table[z]-(TargetTxPwr[band][i] + coarse_tx_delta))<0.5)
			{
				msrd=ref_table[z];
				peak=z;
				power_table[(unsigned)(peak+0.5)]=msrd;
				search=1;
				break;
			}
		}
		while(fabs(msrd-TargetTxPwr[band][i])>0.5 && num_trials<MAX_TX_TRIALS && upper_limit>lower_limit+1 && search==0)
		{
			if(msrd>TargetTxPwr[band][i])
			{
				upper_limit=(unsigned)(peak+0.5);           // know that correct value of peak is lower than current
				peak=(peak+lower_limit)/2;  // search halfway between current value and minimum
			}
			else
			{
				lower_limit=(unsigned)(peak+0.5);           // know that correct value of peak is higher than current
				peak=(peak+upper_limit)/2;  // search halfway between current value and maximum
			}
			num_trials++;
			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);
			expected_power=get_expected_power(power_table,(unsigned)(peak+0.5));
			stat=cal_measure.GetTxPowerDown(expected_power,&msrd);
			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))
			{
				hard_lower_limit=(unsigned)(peak-0.5);  // don't go below this - can't measure the power
				msrd=-3.0;             // set this artificially low to indicate low power
			}
		}
    	
		if(num_trials==MAX_TX_TRIALS)  // let the first index be less than target power
        {
			return TOO_MANY_TX_TRIALS;
        }
		measured[i-GSM850_STARTING_RAMP_INDEX]=msrd;
		x[i-GSM850_STARTING_RAMP_INDEX]=(unsigned)(peak+0.5);
	} // end for all GSM power levels
    
    number_of_points=GSM850_ENDING_RAMP_INDEX-GSM_STARTING_RAMP_INDEX+3;

    // check min power to see if it's less than 5 dB above expected value
	if(measured[number_of_points-3]-TargetTxPwr[band][GSM850_ENDING_RAMP_INDEX]>5.00)
	{
		min_power_too_large=TRUE;
	}
	else
	{
		min_power_too_large=FALSE;
	}

// 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 in version 6.28 for calculating pedestal values
// build a ramp for power level 19 (index 17)
    
// 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].llimit=0;
    m[2].ulimit=1;
// 3 points
    num_msmnt_pts=3;
	current_ramp=17;
	up_length=ramp_up_length[14];
    down_length=ramp_down_length[14];
    up_delta=ramp_up_delta[14];
    down_delta=ramp_down_delta[14];
    pedestal_slope=ramp_pedestal_slope[14];
    pedestal_power=ramp_pedestal_power[14];
    low_power_pedestal=pedestal_slope*(pedestal_power-measured[number_of_points-3])+x[number_of_points-3];
    cal_measure.GetUpperRampStatus((unsigned)TRUE,TargetTxPwr[GSM850][current_ramp],num_msmnt_pts,m);


	count=0;
    pedestal_done=FALSE;
    too_high=0; // haven't been too low or too high yet
    too_low=0;
    pedestal_step=COARSE_PEDESTAL_STEP;
	while(!pedestal_done)
	{
		if(too_high && too_low)
			pedestal_step=FINE_PEDESTAL_STEP;
		build_infineon_trial_ramp(trial_ramp,TargetTxPwr[GSM850][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[GSM850][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)
        {
			low_power_pedestal-=pedestal_step;
			too_high=1;
        }
		else if(!m[0].passed || !m[1].passed)
        {
			low_power_pedestal+=pedestal_step;
			too_low=1;
        }

	}
 	if(!pedestal_done)
		return INFINEON_PEDESTAL_ERROR;

// added in version 6.44 for calculating pedestal value at higher power
// build a ramp for power level 10 (index 8)
    
// 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, -38 dB, lower limit
    m[1].time=-18.0e-6;
    m[1].power=-39.0;
    m[1].llimit=1;
    m[1].ulimit=0;
// m2 = -18 usec, -33 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;
	current_ramp=9;
	up_length=ramp_up_length[6];
    down_length=ramp_down_length[6];
    up_delta=ramp_up_delta[6];
    down_delta=ramp_down_delta[6];
    high_power_pedestal=low_power_pedestal-100;
    cal_measure.GetUpperRampStatus((unsigned)TRUE,TargetTxPwr[GSM850][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[GSM850][current_ramp],
			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[GSM850][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)
        {
			high_power_pedestal-=pedestal_step;
			too_high=1;
        }
		else if(!m[0].passed || !m[1].passed)
        {
			high_power_pedestal+=pedestal_step;
			too_low=1;
        }
	}
	if(!pedestal_done)
		return INFINEON_PEDESTAL_ERROR;
// build all the ramps now, using the pedestal value just calculated for all of them
	for(i=0;i<RAMP_TABLE_SIZE;i++)
	{
		if(i<5)
        {
			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 if(i>17)
        {
			up_length=ramp_up_length[14];
			down_length=ramp_down_length[14];
			up_delta=ramp_up_delta[14];
			down_delta=ramp_down_delta[14];
        }
		else
        {
			up_length=ramp_up_length[i-GSM850_STARTING_RAMP_INDEX];
			down_length=ramp_down_length[i-GSM850_STARTING_RAMP_INDEX];
			up_delta=ramp_up_delta[i-GSM850_STARTING_RAMP_INDEX];
			down_delta=ramp_down_delta[i-GSM850_STARTING_RAMP_INDEX];
        }
// version 6.28 - use the calculated pedestal value
//      pedestal=pedestal_slope*(pedestal_power-measured[number_of_points-3])+x[number_of_points-3];
// ramp up
		for(j=0;j<NUMBER_OF_RAMP_POINTS;j++)
        {
			if(j>up_length-1)
			{
				factor=1.0;
			}
			else
			{
				if(i<=10 && j>=3 && j<=8)
				{
					factor=1-cos((PI*j)/(2*up_length-2))*cos((PI*j)/(2*up_length-2))+.04;
				}
				else
				{
					factor=1-cos((PI*j)/(2*up_length-2))*cos((PI*j)/(2*up_length-2));
				}
			}

			if((i==8 || i==9) && j==11)
				factor=factor-.065;

			power=TargetTxPwr[GSM850][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<=8) // reduce pedestal for power levels <= 10 (index <= 8)
			{
				if(dac_code<high_power_pedestal)
				{
				dac_code=high_power_pedestal;
				}
			}
			else
			{
				if(dac_code<low_power_pedestal)
				{
				dac_code=low_power_pedestal;
				}
			}

			if(i>=6 && i<=14)
			{
				if(up_length<16 && j<=1)
				{
					ramp_table[j][2*i]=dac_code;
				}
				else if(up_length<16 && j>1)
				{
					ramp_table[j][2*i]=prev_dac_code;
				}
			}
			else
				ramp_table[j][2*i]=dac_code;

			prev_dac_code=dac_code;
		} // for all ramp up points within a power level
		if(i<=8)
		{
			ramp_table[0][2*i]=high_power_pedestal;
		}
		else
        {
			ramp_table[0][2*i]=low_power_pedestal;
        }
		

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

			if(j<=16-down_length-offset)
			{
				factor=0.0;
			}
			else
			{
				if(i<5)
				{
					if(j<int(down_length-7))
						//factor=1-cos((PI*(j+1-(16-down_length-offset)))/(2.4*down_length));
						factor=1-(cos((PI*(j+1-(16-down_length-offset)))/(2.85*down_length))*cos((PI*(j+1-(16-down_length-offset)))/(2.85*down_length)));
					else
						factor=1-(cos((PI*(j+1-(16-down_length-offset)))/(2.0*down_length))*cos((PI*(j+1-(16-down_length-offset)-3))/(2.0*down_length)));
					if(j==7)
						factor=factor+.05;
					if(j==8)
						factor=factor-.04;
					if(j>=3 & j<=6)
						factor=factor-.02;

				}
				else if (i>=5 && i<=11 && i!=9 && i!=10)
				{
					if(j<int(down_length-7-offset))
						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(j>=4 && j<=5)
						factor=factor-.01;
					else if(j==6)
						factor=factor+.025;
					else if(j==7)
						factor=factor-.1;
				}
				else
				{
					if(j<int(down_length-7-offset))
						factor=1-cos((PI*(j+1-(16-down_length-offset)))/(2.3*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(j==6)
						factor=factor+.03;
					if(i>=9 && j==5)
						factor=factor+.02;
				}

			}

			if (i<4)
			{
				power=TargetTxPwr[GSM850][i]-factor*down_delta-.8;
			}
			else
			{
				power=TargetTxPwr[GSM850][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 down points within a power level
      } // for all power levels
    } // end if band==GSM850

  if(error==SUCCESS && min_power_too_large)
    {
	  return MIN_POWER_TOO_LARGE;
    }
  else
    {
    return SUCCESS;
    }
  } // end cal_inf_apc


// interpolate the DAC value that corresponds to the target power
// Pass in:
// target power (target_y)
// array of DAC values (x)
// array of corresponding measured powers (y)
// the length of the table
// It is