cal_inf_apc_1.cpp

这是一个手机校准程序

	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[DCS][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[DCS][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[DCS][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[DCS][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[DCS][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-DCS_STARTING_RAMP_INDEX];
			down_length=ramp_down_length[i-DCS_STARTING_RAMP_INDEX];
			up_delta=ramp_up_delta[i-DCS_STARTING_RAMP_INDEX];
			down_delta=ramp_down_delta[i-DCS_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==8 || i==9 || i==10)
			{
				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>=13 && i<=17)
			{
				if (j==10 || j==12)
					factor=old_factor;
				old_factor=factor;
				if (i==13 && (j>=9 & j<=12))
						factor=factor-.05;
			}
			
			power=TargetTxPwr[DCS][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;
	}

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

        power=TargetTxPwr[DCS][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==DCS

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

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

// first, find DAC value that gives highest power
	peak=(float)canonical_pcs_ramp[15];
	i=PCS_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,PCS_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,PCS_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=PCS_STARTING_RAMP_INDEX+1;i<=PCS_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,PCS_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,PCS_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-PCS_STARTING_RAMP_INDEX]=msrd;
		x[i-PCS_STARTING_RAMP_INDEX]=(unsigned)(peak+0.5);
	} // end for all GSM power levels
    
	number_of_points=PCS_ENDING_RAMP_INDEX-PCS_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][PCS_ENDING_RAMP_INDEX]>5.00)
	{
		min_power_too_large=TRUE;
	}
	else
	{
		min_power_too_large=FALSE;
	}