cal_gen5.c

Atheros AP Test with Agilent N4010A source code

	if( (fStream = fopen("ArtLog.txt", "w+")) == NULL ) {
                        printf("\nFailed to open ArtLog.txt\n");
            return;
        }
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'1',fStream);
	fputc((int)'0',fStream);
	fputc((int)'0',fStream);
	fclose(fStream);
exit(0);			
			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;
		findFirstAnchor = TRUE;
		while (findFirstAnchor) {
			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);
//			printf("First anchor Power measured: %f\n", txPower);		//++JC++

			//check to see if first anchor is -ve if so try to get +ve
			if(txPower < 0) {
				anchor_pcdac += 10;
			}
			else {
				findFirstAnchor = FALSE;
			}
		}

		//Try to get near mid power - 10dBm, or maxpower - 15 if maxpower > 23 dBm
		if (maxPower > 23) {
			target_anchor_power = (maxPower - 12);
		}

		anchor_pcdac = anchor_pcdac - 2 * ((A_UINT16)txPower - target_anchor_power);
		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;
		}

		refineAnchor = TRUE;
		while(refineAnchor) {
			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);
//			printf("Anchor Power measured: %f\n", txPower);		//++JC++
//			printf("Anchor pcdac : %d\n", anchor_pcdac);		//++JC++
			if( (txPower > target_anchor_power + 1)	|| (txPower < target_anchor_power - 1)) {
				//further refine the anchor to get closer to target
				anchor_pcdac = anchor_pcdac - 2 * ((A_UINT16)txPower - target_anchor_power);
			} else {
				refineAnchor = FALSE;
			}
		}


		anchor_power_t4 = (A_INT16)((4 * txPower) + 0.5);
		//printf("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
*/
		jj = 0;
		while (jj < CalSetup.numPdGains) {
			if (jj < 1) {
				initial_power[0] = 0;
			} else {
//				initial_power[jj] = (CalSetup.pdGainBoundary[jj-1] - CalSetup.pdGainOverlap/2)/2.0;
								initial_power[jj] = (CalSetup.pdGainBoundary[jj-1] - MEAS_OVERLAP_HALF_DB)/2.0;
			}

			if (jj == (CalSetup.numPdGains - 1)) {
				power_delta[jj] = ((0.8 + (double)(CalSetup.pdGainBoundary[jj] +
//									CalSetup.pdGainOverlap/2 - 2*initial_power[jj]) / (NUM_POINTS_LAST_PDGAIN - 1)))/2;
									MEAS_OVERLAP_HALF_DB - 2*initial_power[jj]) / (NUM_POINTS_LAST_PDGAIN - 1)))/2;
				//printf("SNOOP: last jj=%d, up=%d, init=%3.1f, ovr=%d, numPt=%d\n", jj, CalSetup.pdGainBoundary[jj], initial_power[jj],
			//	CalSetup.pdGainOverlap, NUM_POINTS_LAST_PDGAIN);
			} else {
				power_delta[jj] = ((0.8 + (double)(CalSetup.pdGainBoundary[jj] +
//									CalSetup.pdGainOverlap/2 - 2*initial_power[jj]) / (NUM_POINTS_OTHER_PDGAINS - 1)))/2;
									MEAS_OVERLAP_HALF_DB - 2*initial_power[jj]) / (NUM_POINTS_OTHER_PDGAINS - 1)))/2;
				//printf("SNOOP: earlier jj=%3.1f, up=%d, init=%d, ovr=%d, numPt=%d\n", jj, CalSetup.pdGainBoundary[jj], initial_power[jj],
			//	CalSetup.pdGainOverlap, NUM_POINTS_OTHER_PDGAINS);
			}
		//printf("SNOOP: jj=%d : initial_power = %3.1f, power_delta = %3.1f\n", jj, initial_power[jj],
//	power_delta[jj]);
			jj++;
		}

		for (jj=0; jj < CalSetup.numPdGains; 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 == (CalSetup.numPdGains - 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++) {

				backoff_step = 0;
				backoff_power = TRUE; // mechanism to ensure Vpd_delta < 64

				while (backoff_power) {
					current_pcdac = (A_UINT16)(initial_pcdac[jj] + (ll * 2 * power_delta[jj] * intercept_scale[ll]) - backoff_step);
		//printf("SNOOP: curr_pcdac = %d, scale = %3.1f\n", current_pcdac, intercept_scale[ll]);

	/*
					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);

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

					art_txContEnd(devNum);
					rddata = art_regRead(devNum, 0xa264);
					//printf(">>>REadData VALUE %x\n", rddata);
					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));
					if (ll > 0) {
						if((pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].Vpd[ll] -
						 pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].Vpd[ll-1]) > 63){
							backoff_power = TRUE; // mechanism to ensure Vpd_delta < 64
							backoff_step += 1;    // 0.5dB step
						} else if((pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pwr_t4[ll] -
						 pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pwr_t4[ll-1]) > 28){
							backoff_power = TRUE; // mechanism to ensure Vpd_delta < 64
							backoff_step += (pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pwr_t4[ll] -
											 pRawDataset_gen5[mode]->pDataPerChannel[ii].pDataPerPDGain[jj].pwr_t4[ll-1] - 28)/2;    // 0.5dB step
							//printf("SNOOP: backoff_step = %d\n", backoff_step);
						} else {
							backoff_power = FALSE;
						}
					}
					else {
						backoff_power = FALSE;
					}

///printf("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
}


A_BOOL setup_datasets_for_cal_gen5(A_UINT32 devNum, A_UINT32 mode) {

	A_UINT16	myNumRawChannels ;
	A_UINT16	*pMyRawChanList ;
	A_BOOL		read_from_file = CalSetup.readFromFile;
	A_BOOL		force_piers = CalSetup.forcePiers;


	if (mode != MODE_11a) {
		read_from_file		= CalSetup.readFromFile_2p4[mode];
		myNumRawChannels	= 3;
		force_piers		= CalSetup.forcePiers_2p4[mode];
	}


	// handle forcePierList case here
	if(force_piers && !read_from_file) // 'cause read from file supercedes
	{
		myNumRawChannels = (A_UINT16) ((mode == MODE_11a) ? CalSetup.numForcedPiers : CalSetup.numForcedPiers_2p4[mode]);
		if ((mode == MODE_11b) && (CalSetup.useOneCal)) {
			myNumRawChannels = 3; // 2412, 2472, 2484
		}
		pMyRawChanList	 = ((mode == MODE_11a) ? CalSetup.piersList : CalSetup.piersList_2p4[mode]);
	} else {
		uiPrintf("Automatic pier computation for gen5 not supported yet. Please specify the forced_piers_list\n");
	}

	pRawDataset_gen5[mode]->xpd_mask = CalSetup.cal_mult_xpd_gain_mask[mode];
	if (!setup_raw_dataset_gen5(devNum, pRawDataset_gen5[mode], myNumRawChannels, pMyRawChanList)) {
		uiPrintf("Could not setup raw dataset for gen5 cal for mode %d\n", mode);
		return(0);
	}

	pRawGainDataset_gen5[mode]->xpd_mask = CalSetup.cal_mult_xpd_gain_mask[mode];
	if (!setup_raw_dataset_gen5(devNum, pRawGainDataset_gen5[mode], myNumRawChannels, pMyRawChanList)) {
		uiPrintf("Could not setup raw gainF dataset for gen5 cal for mode %d\n", mode);
		return(0);
	}

	if (!setup_EEPROM_dataset_gen5(devNum, pCalDataset_gen5[mode], myNumRawChannels, pMyRawChanList)) {
		uiPrintf("Could not setup cal dataset for gen5 cal for mode %d\n", mode);
		return(0);
	}

	return(1);
}

void dump_raw_data_to_file_gen5( RAW_DATA_STRUCT_GEN5 *pRawData, char *filename )
{
	A_UINT16		i, j, kk;
	FILE			*fStream;
//	A_UINT16		single_xpd = 0xDEAD;
	A_UINT16		xgain_list[4];
	A_UINT16		xpd_mask;

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

	kk = 0;
	xpd_mask = pRawData->xpd_mask;

	for (j = 0; j < MAX_NUM_PDGAINS_PER_CHANNEL; j++) {
		if (((xpd_mask >> j) & 1) > 0) {
			if (kk > 3) {
				uiPrintf("ERROR: A maximum of 4 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_x1  pwr2_x1  pwr3_x1  pwr4_x1  pwr5_x1");
	if (xgain_list[3] != 0xDEAD) {
		fprintf(fStream, "  pwr1_x3 pwr2_x3 pwr3_x3 pwr4_x3\n");
		fprintf(fStream, "        [vpd]    [vpd]    [vpd]    [vpd]   [vpd]    [vpd]    [vpd]   [vpd]   [vpd]\n");
	} else {
		fprintf(fStream, "\n        [vpd]    [vpd]    [vpd]    [vpd]    [vpd]    \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].pDataPerPDGain[j].numVpd; kk++) {
			fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].pDataPerPDGain[j].pwr_t4[kk]/4.0));
		}
		if (xgain_list[3] != 0xDEAD) {
			j = xgain_list[3];
			for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerPDGain[j].numVpd; kk++) {
				fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].pDataPerPDGain[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].pDataPerPDGain[j].numVpd; kk++) {
			fprintf(fStream, "    [%3d]", pRawData->pDataPerChannel[i].pDataPerPDGain[j].Vpd[kk]);
		}
		if (xgain_list[3] != 0xDEAD) {
			j = xgain_list[3];
			for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerPDGain[j].numVpd; kk++) {
				fprintf(fStream, "    [%3d]", pRawData->pDataPerChannel[i].pDataPerPDGain[j].Vpd[kk]);
			}
		}