📄 meeprom_g.c
字号:
setup_raw_dataset_gen5(devNum, pRawDataset_gen5[MODE_11G], pCalDataset_gen5[MODE_11G]->numChannels, pCalDataset_gen5[MODE_11G]->pChannels);
eeprom_to_raw_dataset_gen5(devNum, pCalDataset_gen5[MODE_11G], pRawDataset_gen5[MODE_11G]);
} else {
pRawDataset_gen5[MODE_11G] = NULL;
pCalDataset_gen5[MODE_11G] = NULL;
}
// REMEMBER TO FREE THE CAL DATASETS HERE
//printf("SNOOP: initialize_datasets_gen5 : exited\n");
return(1);
}
/*
A_BOOL mdk_getFullPwrTable(A_UINT32 devNum, A_UINT16 numPcdacs, A_UINT16 *pcdacs, A_INT16 *power, A_INT16 maxPower, A_INT16 *retVals) {
A_UINT16 ii;
A_UINT16 idxL = 0;
A_UINT16 idxR = 1;
if (numPcdacs < 2) {
mError(devNum, EINVAL, "at least 2 pcdac values needed in mdk_getFullPwrTable - [%d]\n", numPcdacs);
return(FALSE);
}
for (ii=0; ii<64; ii++) {
if ((ii>pcdacs[idxR]) && (idxR < (numPcdacs-1))) {
idxL++;
idxR++;
}
retVals[ii] = mdk_GetInterpolatedValue_Signed16(ii, pcdacs[idxL], pcdacs[idxR], power[idxL], power[idxR]);
if (retVals[ii] >= maxPower) {
while (ii<64) {
retVals[ii++] = maxPower;
}
}
}
return(TRUE);
}
*/
/*
A_INT16 getPminAndPcdacTableFromPowerTable(A_INT16 *pwrTable_t4, A_UINT16 retVals[]) {
A_INT16 ii, jj, jj_max;
A_INT16 Pmin, currPower, Pmax;
// if the spread is > 31.5dB, keep the upper 31.5dB range
if ((pwrTable_t4[63] - pwrTable_t4[0]) > 126) {
Pmin = (A_INT16) (pwrTable_t4[63] - 126);
} else {
Pmin = pwrTable_t4[0];
}
Pmax = pwrTable_t4[63];
jj_max = 63;
// search for highest pcdac 0.25dB below maxPower
while ((pwrTable_t4[jj_max] > (Pmax - 1) ) && (jj_max >= 0)){
jj_max--;
}
jj = jj_max;
currPower = Pmax;
for (ii=63; ii>=0; ii--) {
while ((jj<64) && (jj>0) && (pwrTable_t4[jj] >= currPower)) {
jj--;
}
if (jj == 0) {
while (ii >= 0) {
retVals[ii] = retVals[ii+1];
ii--;
}
break;
}
retVals[ii] = jj;
currPower -= 2; // corresponds to a 0.5dB step
}
return(Pmin);
}
*/
/*
A_INT16 getPminAndPcdacTableFromTwoPowerTables(A_INT16 *pwrTableLXPD_t4, A_INT16 *pwrTableHXPD_t4, A_UINT16 retVals[], A_INT16 *Pmid) {
A_INT16 ii, jj, jj_max;
A_INT16 Pmin, currPower, Pmax;
A_INT16 *pwrTable_t4;
A_UINT16 msbFlag = 0x40; // turns on the 7th bit of the pcdac
// if the spread is > 31.5dB, keep the upper 31.5dB range
if ((pwrTableLXPD_t4[63] - pwrTableHXPD_t4[0]) > 126) {
Pmin = (A_INT16)(pwrTableLXPD_t4[63] - 126);
} else {
Pmin = pwrTableHXPD_t4[0];
}
Pmax = pwrTableLXPD_t4[63];
jj_max = 63;
// search for highest pcdac 0.25dB below maxPower
while ((pwrTableLXPD_t4[jj_max] > (Pmax - 1) ) && (jj_max >= 0)){
jj_max--;
}
*Pmid = pwrTableHXPD_t4[63];
jj = jj_max;
ii = 63;
currPower = Pmax;
pwrTable_t4 = &(pwrTableLXPD_t4[0]);
while(ii >= 0) {
if ((currPower <= *Pmid) || ( (jj == 0) && (msbFlag == 0x40))){
msbFlag = 0x00;
pwrTable_t4 = &(pwrTableHXPD_t4[0]);
jj = 63;
}
while ((jj>0) && (pwrTable_t4[jj] >= currPower)) {
jj--;
}
if ((jj == 0) && (msbFlag == 0x00)) {
while (ii >= 0) {
retVals[ii] = retVals[ii+1];
ii--;
}
break;
}
retVals[ii] = (A_UINT16)(jj | msbFlag);
currPower -= 2; // corresponds to a 0.5dB step
ii--;
}
return(Pmin);
}
*/
void copyGen5EepromStruct
(
EEPROM_FULL_DATA_STRUCT_GEN5 *pFullCalDataset_gen5,
EEPROM_DATA_STRUCT_GEN5 *pCalDataset_gen5[]
)
{
if (pCalDataset_gen5[MODE_11A] != NULL) {
//copy the 11a structs
pFullCalDataset_gen5->numChannels11a = pCalDataset_gen5[MODE_11A]->numChannels;
pFullCalDataset_gen5->xpd_mask11a = pCalDataset_gen5[MODE_11A]->xpd_mask;
memcpy(pFullCalDataset_gen5->pDataPerChannel11a, pCalDataset_gen5[MODE_11A]->pDataPerChannel,
sizeof(EEPROM_DATA_PER_CHANNEL_GEN5) * pCalDataset_gen5[MODE_11A]->numChannels);
}
if (pCalDataset_gen5[MODE_11B] != NULL) {
//copy the 11b structs
pFullCalDataset_gen5->numChannels11b = pCalDataset_gen5[MODE_11B]->numChannels;
pFullCalDataset_gen5->xpd_mask11b = pCalDataset_gen5[MODE_11B]->xpd_mask;
memcpy(pFullCalDataset_gen5->pDataPerChannel11b, pCalDataset_gen5[MODE_11B]->pDataPerChannel,
sizeof(EEPROM_DATA_PER_CHANNEL_GEN5) * pCalDataset_gen5[MODE_11B]->numChannels);
}
if (pCalDataset_gen5[MODE_11G] != NULL) {
//copy the 11g structs
pFullCalDataset_gen5->numChannels11g = pCalDataset_gen5[MODE_11G]->numChannels;
pFullCalDataset_gen5->xpd_mask11g = pCalDataset_gen5[MODE_11G]->xpd_mask;
memcpy(pFullCalDataset_gen5->pDataPerChannel11g, pCalDataset_gen5[MODE_11G]->pDataPerChannel,
sizeof(EEPROM_DATA_PER_CHANNEL_GEN5) * pCalDataset_gen5[MODE_11G]->numChannels);
}
}
A_BOOL get_gain_boundaries_and_pdadcs_for_powers
(
A_UINT32 devNum, // In
A_UINT16 channel, // In
RAW_DATA_STRUCT_GEN5 *pRawDataset, // In
A_UINT16 pdGainOverlap_t2, // In
A_INT16 *pMinCalPower, // Out (2 x min calibrated power)
A_UINT16 pPdGainBoundaries[], // Out
A_UINT16 pPdGainValues[], // Out
A_UINT16 pPDADCValues[] // Out
)
{
A_UINT32 ii, jj, kk;
A_INT32 ss; // potentially -ve index for taking care of pdGainOverlap
A_UINT32 idxL, idxR;
A_UINT32 numPdGainsUsed = 0;
A_UINT16 VpdTable_L[MAX_NUM_PDGAINS_PER_CHANNEL][MAX_PWR_RANGE_IN_HALF_DB]; // filled out Vpd table for all pdGains (chanL)
A_UINT16 VpdTable_R[MAX_NUM_PDGAINS_PER_CHANNEL][MAX_PWR_RANGE_IN_HALF_DB]; // filled out Vpd table for all pdGains (chanR)
A_UINT16 VpdTable_I[MAX_NUM_PDGAINS_PER_CHANNEL][MAX_PWR_RANGE_IN_HALF_DB]; // filled out Vpd table for all pdGains (interpolated)
// if desired to support -ve power levels in future, just change pwr_I_0 to signed 5-bits.
A_INT16 Pmin_t2[MAX_NUM_PDGAINS_PER_CHANNEL]; // to accomodate -ve power levels later on.
A_INT16 Pmax_t2[MAX_NUM_PDGAINS_PER_CHANNEL]; // to accomodate -ve power levels later on
A_UINT16 numVpd = 0;
A_UINT16 Vpd_step;
A_INT16 tmpVal ;
A_UINT32 sizeCurrVpdTable, maxIndex, tgtIndex;
// get upper lower index
mdk_GetLowerUpperIndex(channel, pRawDataset->pChannels, pRawDataset->numChannels, &(idxL), &(idxR));
//printf ("SNOOP: idxL = %d, idxR = %d, pdOverlap*2 = %d\n", idxL, idxR, pdGainOverlap_t2);
for (ii = 0; ii < MAX_NUM_PDGAINS_PER_CHANNEL; ii++) {
jj = MAX_NUM_PDGAINS_PER_CHANNEL - ii - 1; // work backwards 'cause highest pdGain for lowest power
numVpd = pRawDataset->pDataPerChannel[idxL].pDataPerPDGain[jj].numVpd;
//printf("SNOOP: ii[%d], jj[%d], numVpd = %d\n", ii, jj, numVpd);
if (numVpd > 0) {
pPdGainValues[numPdGainsUsed] = pRawDataset->pDataPerChannel[idxL].pDataPerPDGain[jj].pd_gain;
Pmin_t2[numPdGainsUsed] = pRawDataset->pDataPerChannel[idxL].pDataPerPDGain[jj].pwr_t4[0];
if (Pmin_t2[numPdGainsUsed] > pRawDataset->pDataPerChannel[idxR].pDataPerPDGain[jj].pwr_t4[0]) {
Pmin_t2[numPdGainsUsed] = pRawDataset->pDataPerChannel[idxR].pDataPerPDGain[jj].pwr_t4[0];
}
Pmin_t2[numPdGainsUsed] = (A_INT16)(Pmin_t2[numPdGainsUsed] / 2);
Pmax_t2[numPdGainsUsed] = pRawDataset->pDataPerChannel[idxL].pDataPerPDGain[jj].pwr_t4[numVpd-1];
//printf ("SNOOP: idxL = %d, idxR = %d, numVpd = %d, pMax*4[%d] = %d\n", idxL, idxR, numVpd, numPdGainsUsed, Pmax_t2[numPdGainsUsed]);
if (Pmax_t2[numPdGainsUsed] > pRawDataset->pDataPerChannel[idxR].pDataPerPDGain[jj].pwr_t4[numVpd-1]) {
Pmax_t2[numPdGainsUsed] = pRawDataset->pDataPerChannel[idxR].pDataPerPDGain[jj].pwr_t4[numVpd-1];
}
//printf ("SNOOP: pMax*4[%d] = %d\n", numPdGainsUsed, Pmax_t2[numPdGainsUsed]);
Pmax_t2[numPdGainsUsed] = (A_INT16)(Pmax_t2[numPdGainsUsed] / 2);
//printf ("SNOOP: pMax*2[%d] = %d\n", numPdGainsUsed, Pmax_t2[numPdGainsUsed]);
//printf("SNOOP: currGainNum = %d, pdGain = %d, Pmin*2 = %d, Pmax*2 = %d\n", numPdGainsUsed, pPdGainValues[numPdGainsUsed], Pmin_t2[numPdGainsUsed], Pmax_t2[numPdGainsUsed]);
fill_Vpd_Table(numPdGainsUsed, Pmin_t2[numPdGainsUsed], Pmax_t2[numPdGainsUsed], &(pRawDataset->pDataPerChannel[idxL].pDataPerPDGain[jj].pwr_t4[0]),
&(pRawDataset->pDataPerChannel[idxL].pDataPerPDGain[jj].Vpd[0]), numVpd, VpdTable_L);
fill_Vpd_Table(numPdGainsUsed, Pmin_t2[numPdGainsUsed], Pmax_t2[numPdGainsUsed], &(pRawDataset->pDataPerChannel[idxR].pDataPerPDGain[jj].pwr_t4[0]),
&(pRawDataset->pDataPerChannel[idxR].pDataPerPDGain[jj].Vpd[0]), numVpd, VpdTable_R);
for (kk = 0; kk < (A_UINT16)(Pmax_t2[numPdGainsUsed] - Pmin_t2[numPdGainsUsed]); kk++) {
VpdTable_I[numPdGainsUsed][kk] = mdk_GetInterpolatedValue_Signed16(channel, pRawDataset->pChannels[idxL], pRawDataset->pChannels[idxR],
(A_INT16)VpdTable_L[numPdGainsUsed][kk], (A_INT16)VpdTable_R[numPdGainsUsed][kk]);
} // fill VpdTable_I for this pdGain
numPdGainsUsed++;
} // if this pdGain is used
}
*pMinCalPower = Pmin_t2[0];
kk = 0; // index for the final table
for (ii = 0; ii < (numPdGainsUsed ); ii++) {
if (ii == (numPdGainsUsed - 1)) {
// artifically stretch the boundary 2dB above the max measured data (~22dBm).
// helps move gain boundary away from the highest tgt pwrs.
pPdGainBoundaries[ii] = (A_UINT16)(Pmax_t2[ii] + PD_GAIN_BOUNDARY_STRETCH_IN_HALF_DB);
} else {
pPdGainBoundaries[ii] = (A_UINT16)( (Pmax_t2[ii] + Pmin_t2[ii+1]) / 2 );
}
if (pPdGainBoundaries[ii] > 63) {
pPdGainBoundaries[ii] = 63;
}
//printf("SNOOP : pdGainBoundary[%d] = %d\n", ii, pPdGainBoundaries[ii]);
// find starting index for this pdGain
if (ii == 0) {
ss = 0; // for the first pdGain, start from index 0
} else {
ss = (pPdGainBoundaries[ii-1] - Pmin_t2[ii]) - pdGainOverlap_t2 + 1;
//ss = (pPdGainBoundaries[ii-1] - Pmin_t2[ii]) - pdGainOverlap_t2 ; // do overlap - 1 below per PH
}
Vpd_step = (A_UINT16)(VpdTable_I[ii][1] - VpdTable_I[ii][0]);
Vpd_step = (A_UINT16)((Vpd_step < 1) ? 1 : Vpd_step);
// -ve ss indicates need to extrapolate data below for this pdGain
while ((ss < 0) && (kk < (PDADC_TABLE_SIZE-1))){
tmpVal = (A_INT16)(VpdTable_I[ii][0] + ss*Vpd_step);
pPDADCValues[kk++] = (A_UINT16)((tmpVal < 0) ? 0 : tmpVal);
ss++;
} // while ss < 0
sizeCurrVpdTable = Pmax_t2[ii] - Pmin_t2[ii];
tgtIndex = pPdGainBoundaries[ii] + pdGainOverlap_t2 - Pmin_t2[ii];
// pick the smaller one
maxIndex = (tgtIndex < sizeCurrVpdTable) ? tgtIndex : sizeCurrVpdTable;
while ((ss < (A_INT16)maxIndex) && (kk < (PDADC_TABLE_SIZE-1))){
pPDADCValues[kk++] = VpdTable_I[ii][ss++];
}
Vpd_step = (A_UINT16)(VpdTable_I[ii][sizeCurrVpdTable-1] - VpdTable_I[ii][sizeCurrVpdTable-2]);
Vpd_step = (A_UINT16)((Vpd_step < 1) ? 1 : Vpd_step);
// for last gain, pdGainBoundary == Pmax_t2, so will have to extrapolate
if (tgtIndex > maxIndex) { // need to extrapolate above
while((ss <= (A_INT16)tgtIndex) && (kk < (PDADC_TABLE_SIZE-1))){
tmpVal = (A_UINT16)(VpdTable_I[ii][sizeCurrVpdTable-1] +
(ss-maxIndex)*Vpd_step);
pPDADCValues[kk++] = (A_UINT16) ((tmpVal > 127) ? 127 : tmpVal);
ss++;
}
} // extrapolated above
} // for all pdGainUsed
while (ii < MAX_NUM_PDGAINS_PER_CHANNEL) {
pPdGainBoundaries[ii] = pPdGainBoundaries[ii-1];
ii++;
}
while (kk < 128) {
pPDADCValues[kk] = pPDADCValues[kk-1];
kk++;
}
// for (ii=0; ii<MAX_NUM_PDGAINS_PER_CHANNEL; ii++) {
// printf("SNOOP: %d : gainValue = %d, gainBoundary = %d\n", ii, pPdGainValues[ii], pPdGainBoundaries[ii]);
// }
// printf("SNOOP: NumPdGainsUsed = %d, minCalPwr = %d\npdadcTable = ", numPdGainsUsed, *pMinCalPower);
// for (ii=0; ii<128; ii++) {
// printf("[%d,%d],", ii, pPDADCValues[ii]);
// }
// printf("\n");
numPdGainsUsed = devNum; // to quiet warnings
return(TRUE);
}
// fill the Vpdlist for indices Pmax-Pmin
void fill_Vpd_Table(A_UINT32 pdGainIdx, A_INT16 Pmin, A_INT16 Pmax, A_INT16 *pwrList,
A_UINT16 *VpdList, A_UINT16 numIntercepts, A_UINT16 retVpdList[][64])
{
A_UINT16 ii, jj, kk;
A_INT16 currPwr = (A_INT16)(2*Pmin); // since Pmin is pwr*2 and pwrList is 4*pwr
A_UINT32 idxL, idxR;
ii = 0;
jj = 0;
if (numIntercepts < 2) {
printf("ERROR : fill_Vpd_Table : numIntercepts should be at least 2\n");
exit(0);
}
while (ii <= (A_UINT16)(Pmax - Pmin)) {
mdk_GetLowerUpperIndex_Signed16(currPwr, pwrList, numIntercepts, &(idxL), &(idxR));
if (idxR < 1) {
idxR = 1; // extrapolate below
}
if (idxL == (A_UINT32)(numIntercepts - 1)) {
idxL = numIntercepts - 2; // extrapolate above
}
//printf("SNOOP: nI=%d,idxL:%d,idxR:%d --> ", numIntercepts, idxL, idxR);
if (pwrList[idxL] == pwrList[idxR]) {
kk = VpdList[idxL];
} else {
kk = (A_UINT16)( ( (currPwr - pwrList[idxL])*VpdList[idxR]+ (pwrList[idxR] - currPwr)*VpdList[idxL])/(pwrList[idxR] - pwrList[idxL]));
}
retVpdList[pdGainIdx][ii] = kk;
//printf("[%d:(%d,%d)[cP%d,PL%d,PR%d,VL%d,VR%d]:%d]\n", ii, idxL, idxR, currPwr, pwrList[idxL], pwrList[idxR], VpdList[idxL], VpdList[idxR], retVpdList[pdGainIdx][ii]);
ii++;
currPwr += 2; // half dB steps
}
}
A_UINT16 fbin2freq_gen5(A_UINT32 fbin, A_UINT32 mode)
{
A_UINT16 returnValue;
if(mode == MODE_11A) {
returnValue = (A_UINT16)(4800 + 5*fbin);
}
else {
returnValue = (A_UINT16)(2300 + fbin);
}
return returnValue;
}
A_BOOL initialize_datasets_forced_eeprom_gen5(A_UINT32 devNum, EEPROM_DATA_STRUCT_GEN5 **pDummyCalDataset_gen5, RAW_DATA_STRUCT_GEN5 **pDummyRawDataset_gen5, A_UINT32 *words, A_UINT16 xpd_mask) {
A_UINT16 start_offset = 0; // for this routine, must pass the array starting at 11g cal data
A_UINT32 maxPiers;
// A_UINT16 numEEPROMWordsPerChannel;
// A_UINT16 wordsForPdgains[] = {4,6,9,12}; // index is 1 less than numPdgains
if (words == NULL) {
mError(devNum, EIO,"initialize_datasets_forced_eeprom_gen5 : null array pointer supplied. Exiting...\n");
return(0);
}
// setup datasets for mode_11b first
start_offset = 0;
maxPiers = NUM_2_4_EEPROM_CHANNELS_GEN5;
*pDummyCalDataset_gen5 = (EEPROM_DATA_STRUCT_GEN5 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN5));
if(NULL == (*pDummyCalDataset_gen5)) {
mError(devNum, ENOMEM, "unable to allocate 11g gen5 cal data struct\n");
return(0);
}
(*pDummyCalDataset_gen5)->xpd_mask = xpd_mask;
if (!read_Cal_Dataset_From_EEPROM_gen5(devNum, (*pDummyCalDataset_gen5), start_offset, maxPiers, &(words[0]), MODE_11G ) ) {
mError(devNum, EIO,"unable to allocate cal dataset (gen5) for mode 11g\n");
return(0);
}
(*pDummyRawDataset_gen5) = (RAW_DATA_STRUCT_GEN5 *)malloc(sizeof(RAW_DATA_STRUCT_GEN5));
if(NULL == (*pDummyRawDataset_gen5)) {
mError(devNum, ENOMEM, "unable to allocate 11g gen5 raw data struct\n");
return(0);
}
(*pDummyRawDataset_gen5)->xpd_mask = xpd_mask;
setup_raw_dataset_gen5(devNum, (*pDummyRawDataset_gen5), (*pDummyCalDataset_gen5)->numChannels, (*pDummyCalDataset_gen5)->pChannels);
eeprom_to_raw_dataset_gen5(devNum, (*pDummyCalDataset_gen5), (*pDummyRawDataset_gen5));
// REMEMBER TO FREE THE CAL DATASETS HERE
return(1);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -