Hi Everyone,
I am sampling a microphone for spectral analysis using a microcontroller simillar to arduino. Due to the nature of application, I am trying to compute everything I can on the microcontroller itself. I have optimized everything so I am getting adequate sampling/FFT speeds.
However, there is a inherited spectral leakage which I initially solved using a hann window. But in doing so, I am getting drastic speed downs as a computational cost. I have tried using all the inbuilt functionalities onboard, so it can be said that everything is being done as fast as it can be (in terms of programming). The alogrithm is fairly simple:
Step 1: Gather samples from microphone using ADC.
Step 2: Apply Hann window:
Step a: for every sample[i] (the sample element), multiply the sample with the multiplier:
(1 - cos(2*PI*i/Sample_size))/2
Step b: repeat Step a for every sample element in the Sample matrix
Step 3: Compute fft of the resultant matrix from Step 2
To initially solve the problem, I wish to apply the hann window, after having computed the fft. I want to do this because I am taking the output of this fft to a computer where I have decent amount of computational power.
The problem is open to both answers and suggestions.
--Asheesh
Hi,
yes, it's not bad idea with a windowing in the frequency domain when having a limited computational power, see e.g. http://www.embedded.com/design/configurable-systems/4008835/DSP-Tricks-Frequency-Domain-Windowing.
Hi, ideally you can, with some numeric differences in the result you can evaluate yourself. When you compute the F transform of the product of two signals (say it y and c), it's equivalent to calculate the convolution of the F transform of each of the two signal:
Yc = F(y×c) YC = F(y) * F(c)
Here there is a simple Matlab script you can use to evaluate differences in the two methods. You can modify y vector to generate virtual signals as sum of functions, or you can use Arduino to acquire a vector of raw signals and then run the script over that vector for a real case study:
Fs= 1e3;
L = Fs;
t = 0:1/Fs:1-1/Fs;
f = Fs/2*linspace(0,1,L/2+1);
y = sin(2*pi*10*t); % Signal
c = (1-cos(2*pi*t))/2; % Hann window
plot(Fs*t,y,'b',Fs*t,c,'r',Fs*t,y.*c,'g')
title('Signal and Hann window')
xlabel('time (milliseconds)')
Y = fft(y,L)/L; % Signal transform
C = fft(c,L)/L; % Hann transform
Yc= fft(y.*c,L)/L; % Time windowed signal transform
YC= conv(Y,C); % Frequency windowed signal transform
% Plot single-sided amplitude spectrum.
figure,subplot(2,1,1)
loglog(f,2*abs(Y(1:L/2+1)),'b',...
f,2*abs(C(1:L/2+1)),'r')
title('Single-Sided Amplitude Spectrum')
legend('Y','C')
subplot(2,1,2)
loglog(f,2*abs(Yc(1:L/2+1)),'g',...
f,2*abs(YC(1:L/2+1)),'k')
legend('Yc','YC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
Thank you folks (Michael and Carlo).
I tried implementing this technique last night.
However, there was one interesting problem. When I now apply inverse FFT, I don't get the complete original signal back. (Haven't tried adjusting sampling rate and ADC averaging though). I think I will have to introduce some sort of distortion in the signal.
I will post this with some images sometime soon.
Thanks again.
Oh yes, my fault. I forgot that when dealing with discrete fourier transform, the dual of multiplication is cyclic convolution, not linear one. So you should not use conv() function in my script, use instead cconv()
YC= cconv(Y,C,L);
After that, when you want to get back the original signal, just use this command
yC = ifft(YC,'symmetric').'*L;
Now, if you compare both time-domain and frequency-domain signal representation for the two methods, you can see that they perfectly match.
I have been working on computational complexity of such algorithms. The problem is inherent in the windowing convolution and FFT.
I am not sure if you could do using scipy;
http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.hamming.html
- Badges
- Science topic
- Similar topics
- Engineering
- Electrical Engineering
- Signal Processing