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

Thanks Carlo, this indeed worked! :)

There is a direct example in this link 

http://www.embedded.com/design/configurable-systems/4008835/DSP-Tricks-Frequency-Domain-Windowing