cal_gen3.c

Atheros AP Test with Agilent N4010A source code

			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			gainF = read_gainf_twice(devNum) ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d, %d]", power, hi_pcd, gainF);
			}
			if ((gainF > 105) && (tmpGainF <= 105)) {
				gainF = tmpGainF;
				power = tmpPower;
				hi_pcd -= 5;
			}
		}
//		if (power > (maxPower - 0.5)) {
		while ((gainF > 99) && (hi_pcd > 32)){
			hi_pcd -= 4;
			art_ForceSinglePCDACTable(devNum, hi_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			gainF = read_gainf_twice(devNum) ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d, %d]", power, hi_pcd, gainF);
			}
		}
//		if ((power > (maxPower - 0.5)) || (power < (maxPower - 1.5))) {
//			art_ForceSinglePCDACTable(devNum, hi_pcd);
//			Sleep(sleep_interval);
//			power = pmMeasAvgPower(devPM, reset) + myAtten ;
//			uiPrintf(", %3.2f[%d]", power, hi_pcd);
//		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = (A_UINT16)(4*power + 0.5);
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3] = hi_pcd;

		hi_pcd = lo_pcd + (A_UINT16)((hi_pcd - lo_pcd)*0.9);
		art_ForceSinglePCDACTable(devNum, hi_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d]", power, hi_pcd);
		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16)(4*power + 0.5);
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2] = hi_pcd;

		hi_pcd = lo_pcd + (A_UINT16)((hi_pcd - lo_pcd)*0.7);
		if ((hi_pcd - lo_pcd) > 31) {
			hi_pcd = lo_pcd + 31; // because pcd_delta mask is only 5 bits
		}
		art_ForceSinglePCDACTable(devNum, hi_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d]", power, hi_pcd);
		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1] = (A_UINT16)(4*power + 0.5);
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1] = hi_pcd;
*/
//		if (CalSetup.cal_mult_xpd_gain_mask[mode] > 0) {
		if ( xgain_list[1] != xgain_list[0] ) {
			art_txContEnd(devNum);
			jj = xgain_list[1];
			if((swDeviceID & 0xff) >= 0x16) {
				art_writeField(devNum, "rf_pdgain_lo", jj);
				art_writeField(devNum, "rf_pdgain_hi", jj);
			} else {
				art_writeField(devNum, "rf_xpd_gain", jj);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].xpd_gain = (A_UINT16)jj;
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].numPcdacs = NUM_POINTS_XPD3;
			art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN,
							rates[0], DESC_ANT_A | USE_DESC_ANT);

			lo_pcd = 20;
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d]", power, lo_pcd);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[0] = (A_UINT16)(4*power + 0.5);
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[0]  = lo_pcd;

			lo_pcd = 35;
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d]", power, lo_pcd);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1] = (A_UINT16)(4*power + 0.5);
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1]  = lo_pcd;

			lo_pcd = max_pcdac;
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d]", power, lo_pcd);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16)(4*power + 0.5);
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2]  = lo_pcd;
		}

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

	} // end channel loop

	art_writeField(devNum, "rf_mixvga_ovr", mixvga_ovr);
	art_writeField(devNum, "rf_mixgain_ovr", mixgain_ovr);
//** 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 dump_raw_data_to_file_gen3( RAW_DATA_STRUCT_GEN3 *pRawData, char *filename )
{
	A_UINT16		i, j, kk;
	FILE			*fStream;
//	A_UINT16		single_xpd = 0xDEAD;
	A_UINT16		xgain_list[2];
	A_UINT16		xpd_mask;

	xgain_list[0] = 0xDEAD;
	xgain_list[1] = 0xDEAD;

	kk = 0;
	xpd_mask = pRawData->xpd_mask;

	for (j = 0; j < NUM_XPD_PER_CHANNEL; j++) {
		if (((xpd_mask >> j) & 1) > 0) {
			if (kk > 1) {
				uiPrintf("ERROR: A maximum of 2 xpd_gains supported in raw data\n");
				exit(0);
			}
			xgain_list[kk++] = (A_UINT16) j;
		}
	}

	if (CalSetup.customerDebug)
		uiPrintf("\nWriting raw data to file %s\n", filename);

	if( (fStream = fopen( filename, "w")) == NULL ) {
		uiPrintf("Failed to open %s for writing - giving up\n", filename);
		return;
	}

	fprintf(fStream, "XPD_Gain_mask = 0x%x\n\n", pRawData->xpd_mask);

	//print the frequency values
	fprintf(fStream, "freq    pwr1    pwr2    pwr3    pwr4");
	if (xgain_list[1] != 0xDEAD) {
		fprintf(fStream, "   pwr1_x3  pwr2_x3   pwr3_x3\n");
		fprintf(fStream, "        [pcd]    [pcd]    [pcd]    [pcd]   [pcd]    [pcd]      [pcd]\n");
	} else {
		fprintf(fStream, "\n        [pcd]    [pcd]    [pcd]    [pcd]    \n");
	}

	for (i = 0; i < pRawData->numChannels; i++) {
		fprintf(fStream, "%d\t", pRawData->pChannels[i]);
		j = xgain_list[0];
		for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
			fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].pDataPerXPD[j].pwr_t4[kk]/4.0));
		}
		if (xgain_list[1] != 0xDEAD) {
			j = xgain_list[1];
			for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
				fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].pDataPerXPD[j].pwr_t4[kk]/4.0));
			}
		}
		fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].maxPower_t4/4.0));
		fprintf(fStream,"\n\t");
		for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
			fprintf(fStream, "[%2d]    ", pRawData->pDataPerChannel[i].pDataPerXPD[j].pcdac[kk]);
		}
		if (xgain_list[1] != 0xDEAD) {
			j = xgain_list[1];
			for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
				fprintf(fStream, "[%2d]    ", pRawData->pDataPerChannel[i].pDataPerXPD[j].pcdac[kk]);
			}
		}
		fprintf(fStream,"\n");
	}

	fclose(fStream);
}

void raw_to_eeprom_dataset_gen3(RAW_DATA_STRUCT_GEN3 *pRawDataset, EEPROM_DATA_STRUCT_GEN3 *pCalDataset) {

	A_UINT16	ii, jj, kk;
	EEPROM_DATA_PER_CHANNEL_GEN3	*pCalCh;
	RAW_DATA_PER_CHANNEL_GEN3		*pRawCh;
	A_UINT16		xgain_list[2];
	A_UINT16		xpd_mask;

	xgain_list[0] = 0xDEAD;
	xgain_list[1] = 0xDEAD;

	pCalDataset->xpd_mask  = pRawDataset->xpd_mask;

	kk = 0;
	xpd_mask = pRawDataset->xpd_mask;

	for (jj = 0; jj < NUM_XPD_PER_CHANNEL; jj++) {
		if (((xpd_mask >> jj) & 1) > 0) {
			if (kk > 1) {
				uiPrintf("A maximum of 2 xpd_gains supported in raw data\n");
				exit(0);
			}
			xgain_list[kk++] = (A_UINT16) jj;
		}
	}

	pCalDataset->numChannels = pRawDataset->numChannels;
	for (ii = 0; ii < pCalDataset->numChannels; ii++) {
		pCalCh = &(pCalDataset->pDataPerChannel[ii]);
		pRawCh = &(pRawDataset->pDataPerChannel[ii]);
		pCalCh->channelValue = pRawCh->channelValue;
		pCalCh->maxPower_t4  = pRawCh->maxPower_t4;

		jj = xgain_list[0];
		pCalCh->pcd1_xg0	   = (pRawCh->pDataPerXPD[jj].pcdac[0]);
		pCalCh->pcd2_delta_xg0 = (pRawCh->pDataPerXPD[jj].pcdac[1] - pRawCh->pDataPerXPD[jj].pcdac[0]);
		pCalCh->pcd3_delta_xg0 = (pRawCh->pDataPerXPD[jj].pcdac[2] - pRawCh->pDataPerXPD[jj].pcdac[1]);
		pCalCh->pcd4_delta_xg0 = (pRawCh->pDataPerXPD[jj].pcdac[3] - pRawCh->pDataPerXPD[jj].pcdac[2]);

		pCalCh->pwr1_xg0    = pRawCh->pDataPerXPD[jj].pwr_t4[0];
		pCalCh->pwr2_xg0    = pRawCh->pDataPerXPD[jj].pwr_t4[1];
		pCalCh->pwr3_xg0    = pRawCh->pDataPerXPD[jj].pwr_t4[2];
		pCalCh->pwr4_xg0    = pRawCh->pDataPerXPD[jj].pwr_t4[3];

		if (xgain_list[1] != 0xDEAD) {
			jj = xgain_list[1];
			pCalCh->pwr1_xg3    = pRawCh->pDataPerXPD[jj].pwr_t4[0];
			pCalCh->pwr2_xg3    = pRawCh->pDataPerXPD[jj].pwr_t4[1];
			pCalCh->pwr3_xg3    = pRawCh->pDataPerXPD[jj].pwr_t4[2];
		} else {
			pCalCh->pwr1_xg3    = 0;
			pCalCh->pwr2_xg3    = 0;
			pCalCh->pwr3_xg3    = 0;
		}
	}
}


void fill_words_for_eeprom_gen3(A_UINT32 *word, A_UINT16 numWords, A_UINT16 *fbin,
							 A_UINT16 dbmmask, A_UINT16 pcdmask, A_UINT16 freqmask)
{

	A_UINT16 idx = 0;
	EEPROM_DATA_PER_CHANNEL_GEN3 *pCalCh;
	A_UINT16	ii;
	A_UINT16	pcdac_delta_mask = 0x1F;
	A_UINT16	pcdac_mask = 0x3F;
	A_UINT16	numPiers;

	// Group 1. 11a Frequency pier locations
	if(CalSetup.calPower && CalSetup.Amode)
	{
		word[idx++] = ( (fbin[1] & freqmask) << 8) | (fbin[0] & freqmask)  ;
		word[idx++] = ( (fbin[3] & freqmask) << 8) | (fbin[2] & freqmask)  ;
		word[idx++] = ( (fbin[5] & freqmask) << 8) | (fbin[4] & freqmask)  ;
		word[idx++] = ( (fbin[7] & freqmask) << 8) | (fbin[6] & freqmask)  ;
		word[idx++] = ( (fbin[9] & freqmask) << 8) | (fbin[8] & freqmask)  ;
	} else {
	}

	//Group 2. 11a calibration data for all frequency piers
	if(CalSetup.calPower && CalSetup.Amode)
	{

		for (ii=0; ii<pCalDataset_gen3[MODE_11a]->numChannels; ii++)
		{
			pCalCh = &(pCalDataset_gen3[MODE_11a]->pDataPerChannel[ii]);

			word[idx++] = ( ( (pCalCh->pwr1_xg0 & dbmmask) << 0) |
							( (pCalCh->pwr2_xg0 & dbmmask) << 8) );

			word[idx++] = ( ( (pCalCh->pwr3_xg0 & dbmmask) << 0) |
							( (pCalCh->pwr4_xg0 & dbmmask) << 8) );

			word[idx++] = ( ( (pCalCh->pcd2_delta_xg0 & pcdac_delta_mask) << 0) |
							( (pCalCh->pcd3_delta_xg0 & pcdac_delta_mask) << 5) |
							( (pCalCh->pcd4_delta_xg0 & pcdac_delta_mask) << 10) );

			word[idx++] = ( ( (pCalCh->pwr1_xg3 & dbmmask) << 0) |
							( (pCalCh->pwr2_xg3 & dbmmask) << 8) );

			word[idx++] = ( ( (pCalCh->pwr3_xg3 & dbmmask) << 0) |
//							( (pCalCh->maxPower_t4 & dbmmask) << 8) );
							( (pCalCh->pcd1_xg0 & pcdac_mask) << 8) ); // starting eeprom 4.3
		}
	} else
	{
	}


	//Group 3. 11b Calibration Piers and Calibration Information

	if(CalSetup.calPower && CalSetup.Bmode)
	{

		numPiers = pCalDataset_gen3[MODE_11b]->numChannels;
		for (ii=0; ii<numPiers; ii++)
		{
			fbin[ii] = freq2fbin(pCalDataset_gen3[MODE_11b]->pChannels[ii]) ;
		}
		if (numPiers < NUM_PIERS_2p4) {
			for (ii=numPiers; ii<NUM_PIERS_2p4; ii++) {
				fbin[ii] = 0;
			}
		}

		for (ii=0; ii<pCalDataset_gen3[MODE_11b]->numChannels; ii++)
		{
			pCalCh = &(pCalDataset_gen3[MODE_11b]->pDataPerChannel[ii]);

			word[idx++] = ( ( (pCalCh->pwr1_xg0 & dbmmask) << 0) |
							( (pCalCh->pwr2_xg0 & dbmmask) << 8) );

			word[idx++] = ( ( (pCalCh->pwr3_xg0 & dbmmask) << 0) |
							( (pCalCh->pwr4_xg0 & dbmmask) << 8) );

			word[idx++] = ( ( (pCalCh->pcd2_delta_xg0 & pcdac_delta_mask) << 0) |
							( (pCalCh->pcd3_delta_xg0 & pcdac_delta_mask) << 5) |
							( (pCalCh->pcd4_delta_xg0 & pcdac_delta_mask) << 10) );

			word[idx++] = ( ( (pCalCh->pwr1_xg3 & dbmmask) << 0) |
							( (pCalCh->pwr2_xg3 & dbmmask) << 8) );

			word[idx++] = ( ( (pCalCh->pwr3_xg3 & dbmmask) << 0) |
//							( (pCalCh->maxPower_t4 & dbmmask) << 8) );
							( (pCalCh->pcd1_xg0 & pcdac_mask) << 8) ); // starting eeprom 4.3
		}
	} else
	{
	}


	//Group 4. 11g Calibration Piers and Calibration Information

	if(CalSetup.calPower && CalSetup.Gmode)
	{
		numPiers = pCalDataset_gen3[MODE_11g]->numChannels;
		for (ii=0; ii<numPiers; ii++)
		{
			fbin[ii] = freq2fbin(pCalDataset_gen3[MODE_11g]->pChannels[ii]) ;
		}
		if (numPiers < NUM_PIERS_2p4) {
			for (ii=numPiers; ii<NUM_PIERS_2p4; ii++) {
				fbin[ii] = 0;
			}
		}

		for (ii=0; ii<pCalDataset_gen3[MODE_11g]->numChannels; ii++)
		{
			pCalCh = &(pCalDataset_gen3[MODE_11g]->pDataPerChannel[ii]);

			word[idx++] = ( ( (pCalCh->pwr1_xg0 & dbmmask) << 0) |
							( (pCalCh->pwr2_xg0 & dbmmask) << 8) );