measure.cpp

在vc上做的802.16d ofdm phy的仿真

#include "global_var.h"
#include "typedef.h"
#include "math.h"
#include "measure.h"

/***************************************************************************
 * Inline functions
 ***************************************************************************/
static inline Int16 square(Int16 x)
{
    int productTmp;

    productTmp = (int)x * x;
   // productTmp >>= (g_pRxSymbolParam->averageEnergyBitWidth - 1);

    if (productTmp >= 32767)
    {
        return (32767);
    }
    else
    {
        return (Int16) productTmp;
    }
}

/***************************************************************************
 * Functions
 ***************************************************************************/

/*******************************************************************************
 *
 * Function:    getDecibel
 *
 * Parameters:  linearValue:		input value to be convert to dB
 *                
 *
 * Returns:   dB corresponding to input value  
 *
 * Description:get dB in the range of input from 0 to 32767;
 *
 ******************************************************************************/
/* look up table function for claculate dB */
/* claculate db =4 * actual db*/

Int16 getDecibel(Int16 linearValue)
{
	Int16 dbValue;
	Int16 low,mid,high;
	linearValue /= 2;

	if(linearValue >= g_dbToLinCriticalValue[192])
	{
		dbValue = 192;
	}
	else
	{
		low = 0;
		high = 192;
		while(low < high-1)
		{
			mid=(low+high)/2;
			if (linearValue < g_dbToLinCriticalValue[mid])
			{
				high = mid;
			}
			else 
			{
				low = mid;
			}     	
    	}	
		dbValue =low ;
	}
       return dbValue;	
}
/*******************************************************************************
 *
 * Function:    rssiMeasure
 *
 * Parameters:  pRssiMeasure		pointer to structure of RSSI measured result 
 *				rxPowerNoise		pointer to structure of channel estimation result
 * 
 *
 * Returns:     none.
 *
 * Description:	Calculation of RSSI.
 *
 ******************************************************************************/
void rssiMeasure (RxPowerParam rxPowerNoise,
					RssiParam *pRssiMeasure)
{
	Int16 revCurrentRssiDb;
	Int16 revCurrentRssi;
	Int16 scaleBitWidth;
	Int16 scaleTmp;
	
	scaleBitWidth = ALPHA_BIT_WIDTH;
	scaleTmp = 1 << scaleBitWidth;

	revCurrentRssiDb = rxPowerNoise.rxPowerDb - pRssiMeasure->agcGain - pRssiMeasure->fixedGain; 
    
    revCurrentRssi = g_dbToLinTable[revCurrentRssiDb];

	if (pRssiMeasure->initialFlag == 0)
	{
		pRssiMeasure->mean = revCurrentRssi;
				
		pRssiMeasure->meanDb = revCurrentRssiDb;

		pRssiMeasure->deviation = square(pRssiMeasure->mean);
		
		pRssiMeasure->stdDeviationDb = 0;

		pRssiMeasure->initialFlag = 1;
	}
	else
	{
		pRssiMeasure->mean = ((scaleTmp - pRssiMeasure->smoothFactor) * pRssiMeasure->mean
							+ pRssiMeasure->smoothFactor * revCurrentRssi) >> scaleBitWidth;

		pRssiMeasure->meanDb = getDecibel(pRssiMeasure->mean);

		pRssiMeasure->deviation = ((Int32)(scaleTmp - pRssiMeasure->smoothFactor) * pRssiMeasure->deviation
									+ pRssiMeasure->smoothFactor * square(revCurrentRssi)) >> scaleBitWidth;						
		
		pRssiMeasure->stdDeviationDb = getDecibel(pRssiMeasure->deviation - square(pRssiMeasure->mean));
		
		pRssiMeasure->stdDeviationDb >>= 1; 

	}
}
/*******************************************************************************
 *
 * Function:    cinrMeasure
 *
 * Parameters:  pCinrMeasure		pointer to structure of CINR measure result 
 *				rxPowerNoise	pointer to structure of channel estimation result           
 *
 * Returns:     none
 *
 * Description:	Calculation of CINR.
 *
 ******************************************************************************/
void cinrMeasure (RxPowerParam rxPowerNoise,
				  CinrParam *pCinrMeasure)
{
	Int16 revCurrentCinrDb;
	Int16 revCurrentCinr;
	Int16 scaleBitWidth;
	Int16 scaleTmp;
	
	scaleBitWidth = ALPHA_BIT_WIDTH;
	scaleTmp = 1 << scaleBitWidth;

	revCurrentCinrDb = rxPowerNoise.rxPowerDb - rxPowerNoise.rxNoiseDb;
	revCurrentCinr = g_dbToLinTable[revCurrentCinrDb];

	if (pCinrMeasure->initialFlag ==0)
	{
		pCinrMeasure->mean = revCurrentCinr;
		
		pCinrMeasure->meanDb = revCurrentCinrDb;

		pCinrMeasure->devation = square(revCurrentCinr);

		pCinrMeasure->stdDeviationDb = 0;

		pCinrMeasure->initialFlag = 1;
	}
	else 
	{
		pCinrMeasure->mean = (scaleTmp - pCinrMeasure->smoothFactor) * pCinrMeasure->mean
							+ pCinrMeasure->smoothFactor * revCurrentCinr;

		pCinrMeasure->meanDb = getDecibel(pCinrMeasure->mean);

		pCinrMeasure->devation = ((Int32)(scaleTmp - pCinrMeasure->smoothFactor)  * pCinrMeasure->devation
								+ pCinrMeasure->smoothFactor * square(pCinrMeasure->mean)) >> scaleBitWidth;

		pCinrMeasure->stdDeviationDb = getDecibel(pCinrMeasure->devation - square(pCinrMeasure->mean));

		pCinrMeasure->stdDeviationDb >>= 1;
	}
}

/* End Of File */