Agfdhyk

A similar question has been asked at Need fastest way to convert 2's complement to decimal in C, but I couldn't use it to get my answer, so posting this...

I have 32-bit data coming from an audio sensor in the following format:-
The Data Format is I2S, 24-bit, 2’s compliment, MSB first. The data precision is 18 bits; unused bits are zeros.

Without any audio input, I am able to read the following data from the sensor:-

• 0xFA578000


• 0xFA8AC000


• 0xFA85C000


• 0xFA828000


• 0xFA800000


• 0xFA7E4000


• 0xFA7D0000


• 0xFA7BC000

and so on...

I need to use these data samples to calculate their RMS value, then further use this RMS value to calculate the decibels (20 * log(rms)).

Here is my code with comments:-

//I have 32-bits, with data in the most-significant 24 bits.



inputVal &= 0xFFFFFF00;    //Mask the least significant 8 bits.



inputVal = inputVal >> 8;  //Data is shifted to least 24 bits. 24th bit is the sign bit.



inputVal &= 0x00FFFFC0;  //Mask the least 6 bits, since data precision is 18 bits.



//So, I have got 24-bit data with masked 6 lsb bits. 24th bit is sign bit.



//Converting from 2's complement.

const int negative = (inputVal & (1 << 23)) != 0;

int nativeInt;



if (negative)

    nativeInt = inputVal | ~((1 << 24) - 1);

else

    nativeInt = inputVal;



return (nativeInt * nativeInt);   //Returning the squared value to calculate RMS

After this, I take the average of sum of squared values and calculate its root to get the RMS value.

My questions are,

1. Am I doing the data bit-manipulations correctly?


2. Is it necessary to convert the data samples from 2's complement to integer to calculate their RMS values?

***********************************************Part-2*****************************************************

Continuing further with @Johnny Johansson's answer:-

It looks like all your sample values are close to -6800, so I assume that is an offset that you need to account for.

To normalize the sample set, I have calculated the mean value of the sample set and subtracted it from each value in the sample set.

Then, I found the maximum and minimum values form the sample set and calculated the peak-to-peak value.

// I have the sample set, get the mean

float meanval = 0;

for (int i=0; i <actualNumberOfSamples ; i++)

{

    meanval += samples[i];

}

meanval /= actualNumberOfSamples;

printf("Average is: %fn", meanval);



// subtract it from all samples to get a 'normalized' output

for (int i = 0; i < actualNumberOfSamples; i++)

{

    samples[i] -= meanval;

}



// find the 'peak to peak' max

float minsample = 100000;

float maxsample = -100000;

float peakToPeakMax = 0.0;

for (int i = 0; i < actualNumberOfSamples; i++)

{

    minsample = fmin(minsample, samples[i]);

    maxsample = fmax(maxsample, samples[i]);

}

peakToPeakMax = (maxsample - minsample);

printf("The peak-to-peak maximum value is: %fn", peakToPeakMax);

(This does not include the RMS part, which comes after you have correct signed integer values)

Now, I calculate the rms value by dividing the peak-to-peak value by square-root of 2.
Then, 20 * log10(rms) gives me the corresponding decibel value.

rmsValue = peak2peakValue / sqrt2;



DB_Val = 20 * log10(rmsValue);

1. Does the above code take care of the " offset " that you mentioned?


2. I am yet to find a test plan to verify the calculated decibels, but have I mathematically calculated the decibel value correctly?

The 2'complement part seems like it should work, but it is unnecessarily complicated, since regular integers are represented using 2'complement (unless you are on some very exotic hardware). You could simply do this instead:

signed int signedInputVal = (signed int)inputVal;

signedInputVal >>= 14;

This will give you a value in the range -(2^17) to (2^17-1).

It looks like all your sample values are close to -6800, so I assume that is an offset that you need to account for.

(This does not include the RMS part, which comes after you have correct signed integer values)