cal_gen5.c

Atheros AP Test with Agilent N4010A source code

					xgain_list[kk++] = ll;
				}
				ll++;
				pd_gain = (pd_gain >> 1);
			}
			if (kk == 1) {
				xgain_list[1] = xgain_list[0];
			}
		}


		art_writeField(devNum, "bb_force_pdadc_gain", 1);
		art_writeField(devNum, "bb_forced_pdadc_gain", 1);

		art_forceSinglePowerTxMax(devNum, 0);
		art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
						rates[0], DESC_ANT_A | USE_DESC_ANT);
		Sleep(50); // sleep 20 ms

		pcdac = 63;
		art_ForceSinglePCDACTable(devNum, pcdac);
		Sleep(sleep_interval);
		maxPower = pmMeasAvgPower(devPM, reset) + myAtten;
		if (maxPower < 10) {
			Sleep(sleep_interval);
			maxPower = pmMeasAvgPower(devPM, reset) + myAtten;
		}

		art_txContEnd(devNum);
		if (maxPower < 10) {
			uiPrintf("The max transmit Power is too small (%3.2f) at ch = %d. Giving up.\n", maxPower, channel);
			REWIND_TEST = TRUE;
			return;
		}

		if (CalSetup.customerDebug) {
			uiPrintf("maxPower = %3.2f", maxPower);
		} else {
			uiPrintf("max pwr is %3.2f dBm\n", maxPower);
		}
		pRawDataset_gen5[mode]->pDataPerChannel[ii].maxPower_t4 = (A_UINT16)(4*maxPower + 0.5);

		// Measure for a pcdac and determine the correlation between pcdac and power
		anchor_pcdac = 22;
		art_ForceSinglePCDACTable(devNum, anchor_pcdac);

		// First get power for a setting that corresponds to almost the mid of the range required
		art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
					DataRate[configSetup.dataRateIndex], configSetup.antenna);
		Sleep(sleep_interval);

		txPower = pmMeasAvgPower(devPM, reset) + myAtten;
		while ((txPower < 5) && (anchor_pcdac < 56)){
//			Sleep(sleep_interval);
//			txPower = pmMeasAvgPower(devPM, reset) + myAtten;

			anchor_pcdac += 4;
//printf("SNOOP: trying an anchor pcdac of %d\n", anchor_pcdac);
			art_txContEnd(devNum);
			art_ForceSinglePCDACTable(devNum, anchor_pcdac);

			// First get power for a setting that corresponds to almost the mid of the range required
			art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
					DataRate[configSetup.dataRateIndex], configSetup.antenna);
			Sleep(sleep_interval);

			txPower = pmMeasAvgPower(devPM, reset) + myAtten;

		}
		art_txContEnd(devNum);
//printf("First Power measured: %f\n", txPower);		//++JC++

		//Try to get near mid power - 10dBm
		anchor_pcdac = anchor_pcdac - 2 * ((A_UINT16)txPower - 10);
		if(anchor_pcdac > 63) {
			uiPrintf("The first Power measurement is too small (%f) at ch = %d. Giving up.\n", txPower, channel);
			REWIND_TEST = TRUE;
			return;
		}

		art_ForceSinglePCDACTable(devNum, anchor_pcdac);

		// First get power for a setting that corresponds to almost the mid of the range required
		art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
					DataRate[configSetup.dataRateIndex], configSetup.antenna);
		Sleep(sleep_interval);

		txPower = pmMeasAvgPower(devPM, reset) + myAtten;
		if (txPower < 5) {
			Sleep(sleep_interval);
			txPower = pmMeasAvgPower(devPM, reset) + myAtten;
		}
		art_txContEnd(devNum);
		//uiPrintf("Anchor Power measured: %f\n", txPower);		//++JC++
		//uiPrintf("Anchor pcdac : %d\n", anchor_pcdac);		//++JC++
		anchor_power_t4 = (A_INT16)((4 * txPower) + 0.5);
		//uiPrintf("Debug:: Anchor_power_t4: %d\n", anchor_power_t4);  //++JC++

		power_pcdac_offset_t4 = (2 * anchor_pcdac) - anchor_power_t4;

		// Setup the lowest power and deltas of power from the lowest for each xpd gain
		initial_power[0] = 0;		// 0 dBm for first xpd gain
		initial_power[1] = 7;		// 7 dBm for second xpd gain
		power_delta[0] = 3;		// 3 dB steps for first xpd gain
		power_delta[1] = 4;		// 4 dB steps for second xpd gain

		for (jj=0; jj<NUM_PDGAINS_PER_CHANNEL; jj++) {
			initial_pcdac[jj] = ((4 * initial_power[jj]) + power_pcdac_offset_t4)/2;		// Get pcdac correspoding to initial pwr
			offset = 30;
			if ((initial_pcdac[jj] < 0) || (initial_pcdac[jj] > 63)){
				offset = 30 + initial_pcdac[jj];
				initial_pcdac[jj] = 0;
			}

			pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pd_gain = (A_UINT16)(xgain_list[jj]);

			if (jj == (NUM_PDGAINS_PER_CHANNEL - 1)){	// For the last xpd gain we have one more than the others
				pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].numVpd = NUM_POINTS_LAST_PDGAIN;
			} else {
				pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].numVpd = NUM_POINTS_OTHER_PDGAINS;
			}
			art_writeField(devNum, "bb_force_pdadc_gain", 1);
			art_writeField(devNum, "bb_forced_pdadc_gain", xgain_list[jj]);

			for (ll=0; ll < pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].numVpd; ll++) {
				current_pcdac = (A_UINT16)(initial_pcdac[jj] + (ll * 2 * power_delta[jj]));
				if (current_pcdac > 63) {
					current_pcdac = 63;
				}
				art_ForceSinglePCDACTableGriffin(devNum, current_pcdac, (A_UINT16)offset);
				art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
							DataRate[configSetup.dataRateIndex], configSetup.antenna);
				Sleep(sleep_interval);
				power_to_store_t4 = (A_UINT16)((2 * (current_pcdac - (30 - offset))) - power_pcdac_offset_t4);


				if ((power_to_store_t4) > 48) {		// Measure for > 15 dBm - remove later if possible
					txPower = pmMeasAvgPower(devPM, reset) + myAtten;
					if (txPower < 5) {
						Sleep(sleep_interval);
						txPower = pmMeasAvgPower(devPM, reset) + myAtten;
					}
//					uiPrintf("\nPower measured: %f\n", txPower);		//++JC++
					power_to_store_t4 = (A_INT16)((txPower * 4) + 0.5);
				}


				art_txContEnd(devNum);
				rddata = art_regRead(devNum, 0xa264);
				if (power_to_store_t4 < 0) {power_to_store_t4 = 0;}
				pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pwr_t4[ll]  = (A_INT16)(power_to_store_t4);
				pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].Vpd[ll]  = (A_UINT16)(((rddata >> 1) & 0xff));

				//uiPrintf("Pcdac: %d \tAvg Out: %d \tPower_t4: %d \n", current_pcdac, pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].Vpd[ll], pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pwr_t4[ll]);	//++JC++ debug
			}
		}



//++JC++


		if (CalSetup.customerDebug) {
			uiPrintf("\n");
		}

	} // end channel loop

//** the following added by ccshiang
	AgN4010_Log_LogIt("<<<*** %s -- End of Collecting raw data for the adapter, %s used ***>>>",modeName[mode],toSeconds(GetTickCount() - ticksTest));
//** the above added by ccshiang
}
*/

void measure_all_channels_generalized_gen5(A_UINT32 devNum, A_UINT32 debug, A_UINT32 mode) {

	A_UINT32	pd_gain, xgain_list[MAX_NUM_PDGAINS_PER_CHANNEL]; // handle max pd_gains
	A_UINT32    local_num_pd_gains;
	A_INT32		ii, jj, kk, ll;
	A_UINT16	channel;
	A_UINT16	pcdac, anchor_pcdac;
	A_UINT32    offset;
	A_UINT16	reset = 0;
	double		txPower;
	A_UCHAR		devlibMode ; // use setResetParams to communicate appropriate mode to devlib
	double		maxPower;
	double		myAtten;
	A_UINT16    sleep_interval = 50;
	A_UINT32 	rddata;
	A_INT16		power_pcdac_offset_t4, power_to_store_t4, anchor_power_t4;
	A_UINT16 	current_pcdac;
	double   	initial_power[MAX_NUM_PDGAINS_PER_CHANNEL], power_delta[MAX_NUM_PDGAINS_PER_CHANNEL];
	A_INT32 	initial_pcdac[MAX_NUM_PDGAINS_PER_CHANNEL];
	A_UINT16    wordsForPdgains[] = {4,6,9,12}; // index is 1 less than numPdgains
	A_UINT16    target_anchor_power = 10; // dBm
	A_BOOL      backoff_power = FALSE;
	A_UINT16    backoff_step = 1; // 0.5 dB
	A_UINT16    MEAS_OVERLAP_HALF_DB = 2; // 1dB overlap
	FILE *fStream;
	//  map intercepts {0, 25, 50, 75, 100} to {0, 35, 65, 85, 100}
	//double      intercept_scale[NUM_POINTS_LAST_PDGAIN] = {1,1.4,1.3,1.13,1};
	double      intercept_scale[NUM_POINTS_LAST_PDGAIN] = {1,1,1,1,1};
	A_BOOL      findFirstAnchor = TRUE;
	A_BOOL      refineAnchor = TRUE;
//** the following added by ccshiang
	double      saved_myAtten;
	configSetup.antenna = DESC_ANT_A | USE_DESC_ANT;
//** the above added by ccshiang


	switch (mode) {
	case MODE_11a :
		devlibMode = MODE_11A;
		pd_gain   = CalSetup.xgain;
		myAtten	   = CalSetup.attenDutPM;
		CalSetup.TrgtPwrStartAddr += 5; // upto 10 piers
		if (CalSetup.pmModel == PM_436A) {
			sleep_interval = 150;
		}
		break;
	case MODE_11g :
		devlibMode = MODE_11G;
		pd_gain   = CalSetup.xgain_2p4[mode];
		myAtten	   = CalSetup.attenDutPM_2p4[mode];
		CalSetup.TrgtPwrStartAddr += 2; // upto 4 piers
		if (CalSetup.pmModel == PM_436A) {
			sleep_interval = 150;
		}
		break;
	case MODE_11b :
		
		
		devlibMode = MODE_11B;		
		pd_gain   = CalSetup.xgain_2p4[mode];
		myAtten	   = CalSetup.attenDutPM_2p4[mode];
		CalSetup.TrgtPwrStartAddr += 2; // upto 4 piers
		if (CalSetup.pmModel == PM_436A) {
			sleep_interval = 250;
		}
		break;
	default:
		uiPrintf("Unknown mode supplied to measure_all_channels_gen5 : %d \n", mode);
		break;
	}
//** the following added by ccshiang
	saved_myAtten = myAtten;
//** the above added by ccshiang

	//++PD++ generalized 4 pd_adc_gain supported --
	if (CalSetup.cal_mult_xpd_gain_mask[mode] == 0) {
			jj = 0;
			pRawDataset_gen5[mode]->xpd_mask = (1 << XPD_GAIN1_GEN5) | (1 << XPD_GAIN2_GEN5);
			xgain_list[0] = XPD_GAIN1_GEN5;
			xgain_list[1] = XPD_GAIN2_GEN5;
	} else {
		jj = 0;
		pRawDataset_gen5[mode]->xpd_mask = (A_UINT16) CalSetup.cal_mult_xpd_gain_mask[mode];
		pd_gain = CalSetup.cal_mult_xpd_gain_mask[mode];
		kk = 0;
		ll = 0;
		while (ll < 4) {
			if ((pd_gain & 0x8) == 0x8) {
				if (kk >= 4) {
					uiPrintf("ERROR: A maximum of 4 pd_gains allowed to be specified in the eep file.\n");
					exit(0);
				}
				xgain_list[kk++] = (MAX_NUM_PDGAINS_PER_CHANNEL - 1) - ll;
			}
			ll++;
			pd_gain = (pd_gain << 1);
		}
	}

	local_num_pd_gains = kk;
	if (local_num_pd_gains != pRawDataset_gen5[mode]->pDataPerChannel[0].numPdGains) {
		uiPrintf("ERROR: num_pd_gains [%d] from xpd_mask [0x%x] does not match with the dataset [%d]\n", local_num_pd_gains,
			CalSetup.cal_mult_xpd_gain_mask[mode],
			pRawDataset_gen5[mode]->pDataPerChannel[0].numPdGains);
		exit(0);
	}
	if (local_num_pd_gains != CalSetup.numPdGains) {
		uiPrintf("ERROR: num_pd_gains [%d] from xpd_mask [0x%x] does not match with the CalSetup.numPdGains in the .eep file [%d]\n", local_num_pd_gains,
			CalSetup.cal_mult_xpd_gain_mask[mode],
			CalSetup.numPdGains);
		exit(0);
	}

	CalSetup.TrgtPwrStartAddr += wordsForPdgains[local_num_pd_gains-1]*pRawDataset_gen5[mode]->numChannels;
	configSetup.eepromLoad = 0;
	art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
					(A_BOOL)configSetup.eepromHeaderLoad, (A_UCHAR)devlibMode, configSetup.use_init);


//** the following added by ccshiang
	ticksTest = GetTickCount();
	AgN4010_Log_LogIt("<<<*** %s -- Collecting raw data for the adapter ***>>>",modeName[mode]);

	agiDo_Cal_Setting();
//** the above added by ccshiang
	uiPrintf("\nL%d, Collecting raw data for the adapter for mode %s\n",_module_line(),modeName[mode]);

	for (ii=0; ii<pRawDataset_gen5[mode]->numChannels; ii++)
	{
		channel = pRawDataset_gen5[mode]->pDataPerChannel[ii].channelValue;

		if (ii == 0)
		{
			art_resetDevice(devNum, txStation, NullID, channel, 0);
		} else
		{
			art_resetDevice(devNum, txStation, NullID, channel, 0);
//			art_changeChannel(devNum, channel); // for efficiency
		}

		uiPrintf("ch: %d  --> ", channel);
//** the following added by ccshiang
		myAtten = saved_myAtten + agiGetCableLost(channel);
//** the above added by ccshiang

		art_writeField(devNum, "bb_force_pdadc_gain", 1);
		// lowest pdadc_gain for max power
		art_writeField(devNum, "bb_forced_pdadc_gain", xgain_list[0]);

	//	art_forceSinglePowerTxMax(devNum, 0);
		art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
						rates[0], DESC_ANT_A | USE_DESC_ANT);
		Sleep(50); // sleep 20 ms

		pcdac = 63;
		art_ForceSinglePCDACTableGriffin(devNum, pcdac, 60); // use max gain setting
		Sleep(sleep_interval);
		maxPower = pmMeasAvgPower(devPM, reset) + myAtten;
		if (maxPower < 10) {
			Sleep(sleep_interval);
			maxPower = pmMeasAvgPower(devPM, reset) + myAtten;
		}

		art_txContEnd(devNum);
		if (maxPower < 10) {
			uiPrintf("The max transmit Power is too small (%3.2f) at ch = %d. Giving up.\n", maxPower, channel);
//TONY