cal_inf_apc_1.cpp

这是一个手机校准程序

    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+30;
    cal_measure.GetUpperRampStatus((unsigned)TRUE,TargetTxPwr[GSM][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[GSM][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[GSM][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<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 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-GSM_STARTING_RAMP_INDEX];
			down_length=ramp_down_length[i-GSM_STARTING_RAMP_INDEX];
			up_delta=ramp_up_delta[i-GSM_STARTING_RAMP_INDEX];
			down_delta=ramp_down_delta[i-GSM_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));
				}
			}

			power=TargetTxPwr[0][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<=10)
			{
				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)
				{
					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(i==5 && i==6)
					//{
						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[0][i]-factor*down_delta-.5;
			}
			else
			{
				power=TargetTxPwr[0][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==GSM

//------------- DCS
else if (band==DCS)
{
	hard_lower_limit=0x1a0;
	hard_upper_limit=0x3ff;

	TargetTxPwr[DCS][0]=TargetTxPwr[DCS][1]=TargetTxPwr[DCS][2]=
	TargetTxPwr[DCS][3]=highest_power;   

// first, find DAC value that gives highest power
	peak=(float)canonical_dcs_ramp[15];
	i=DCS_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,DCS_TRIAL_PEDESTAL);
    cal_hs.HS_SetRamp(trial_ramp);
    Sleep(100);
    stat=cal_measure.GetTxPower(expected_power,&msrd);
    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;
	}
// 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,DCS_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);
		ref_table[(unsigned)(peak+0.5)]=msrd;
		if(stat==FALSE)
        {
			return POWER_ERROR;
        }
		num_trials++;
	}
	if(num_trials==MAX_TX_TRIALS)
	{
		return TOO_MANY_TX_TRIALS;
	}

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

// put the high power value in
	power_table[(unsigned)(peak+0.5)]=msrd;

// now have the highest power and its DAC value
// do binary search for other powers. The limits will be adjusted dynamically    
    
	for(i=DCS_STARTING_RAMP_INDEX+1;i<=DCS_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,GSM_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,DCS_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-DCS_STARTING_RAMP_INDEX]=msrd;
		x[i-DCS_STARTING_RAMP_INDEX]=(unsigned)(peak+0.5);
	} // end for all GSM power levels
    
	number_of_points=DCS_ENDING_RAMP_INDEX-DCS_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][DCS_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 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[DCS][current_ramp],num_msmnt_pts,m);