FFT to spectrum in decibel

admin

https://dsp.stackexchange.com/questions/32076/fft-to-spectrum-in-decibel

Definitely you will have to calibrate your system. You need to know what is the relationship between dBFS (Decibel Full-Scale) and dB scale you want to measure.

In case of digital microphones, you will find sensitivity given in dBFS. This corresponds to dBFS level, given 94 dB SPL (Sound Pressure Level). For example this microphone for input 94dBSPL will produce signal at −26dBFS. Therefore the calibration factor for spectrum will be equal to 94+26=120dB.

Secondly, keep in mind scaling of the spectrum while doing windowing and DFT itself. More specifically, given amplitude spectrum (abs(sp)):

Total energy of the signal is spread over frequencies below and above Nyquist frequency. Naturally we are interested only in half of the spectrum. That is why, it important to multiply it by 2 and ignore everything above the Nyquist frequency.

Whenever doing windowing, it is necessary to compensate for loss of energy due to multiplication by that window. This is defined as division by sum of window samples (sum(win)). In case of rectangular window (or now window), it is as simple as division by N, where N is the DFT length.

Here is some example source code in Python. I am sure that you can take it from here.

1. #!/usr/bin/env python
   
2. 
   
3. import numpy as np
   
4. import matplotlib.pyplot as plt
   
5. import scipy.io.wavfile as wf
   
6. 
   
7. plt.close('all')
   
8. 
   
9. 
   
10. def dbfft(x, fs, win=None, ref=32768):
    
11.     """
    
12.     Calculate spectrum in dB scale
    
13.     Args:
    
14.         x: input signal
    
15.         fs: sampling frequency
    
16.         win: vector containing window samples (same length as x).
    
17.              If not provided, then rectangular window is used by default.
    
18.         ref: reference value used for dBFS scale. 32768 for int16 and 1 for float
    
19. 
    
20.     Returns:
    
21.         freq: frequency vector
    
22.         s_db: spectrum in dB scale
    
23.     """
    
24. 
    
25.     N = len(x)  # Length of input sequence
    
26. 
    
27.     if win is None:
    
28.         win = np.ones(1, N)
    
29.     if len(x) != len(win):
    
30.             raise ValueError('Signal and window must be of the same length')
    
31.     x = x * win
    
32. 
    
33.     # Calculate real FFT and frequency vector
    
34.     sp = np.fft.rfft(x)
    
35.     freq = np.arange((N / 2) + 1) / (float(N) / fs)
    
36. 
    
37.     # Scale the magnitude of FFT by window and factor of 2,
    
38.     # because we are using half of FFT spectrum.
    
39.     s_mag = np.abs(sp) * 2 / np.sum(win)
    
40. 
    
41.     # Convert to dBFS
    
42.     s_dbfs = 20 * np.log10(s_mag/ref)
    
43. 
    
44.     return freq, s_dbfs
    
45. 
    
46. 
    
47. def main():
    
48.     # Load the file
    
49.     fs, signal = wf.read('Sine_440hz_0dB_10seconds_44.1khz_16bit_mono.wav')
    
50. 
    
51.     # Take slice
    
52.     N = 8192
    
53.     win = np.hamming(N)
    
54.     freq, s_dbfs = dbfft(signal[0:N], fs, win)
    
55. 
    
56.     # Scale from dBFS to dB
    
57.     K = 120
    
58.     s_db = s_dbfs + K
    
59. 
    
60.     plt.plot(freq, s_db)
    
61.     plt.grid(True)
    
62.     plt.xlabel('Frequency [Hz]')
    
63.     plt.ylabel('Amplitude [dB]')
    
64.     plt.show()
    
65. 
    
66. if __name__ == "__main__":
    
67.     main()
    

复制代码

Lastly, there is no better source on this type of spectrum scaling than brilliant publication by G. Heinzel et al. Just keep in mind that if you want to proper RMS scaling, then full-scale sinosuidal signal will be −3dBFS.

You might also find my previous answer being helpful.