Wiki

Below is the source of this page. To edit this source as well as other pages on the wiki, you must login.
====== FFT Window Functions ======

===== Background =====
In mathematics, a [[wp>Fourier transform]] (FT) is a mathematical transform that traditionally decomposes time based functions (eg <m>f(t)</m> or <m>x(t)</m> ) into functions in the frequency domain (eg <m>X(omega)</m> or <m>hat{f}(omega)</m>), and is defined by this tranform:

<m>X(omega) = int{-infty}{+infty}{x(t) e^{-2 pi i omega t} dt}</m>

The Fourier transform of a function of time <m>x(t)</m>, is a complex-valued function of frequency <m>X(omega)</m>, whose magnitude (absolute value of the complex value) represents the amount of that frequency present in the original function, and whose argument is the phase offset of the basic sinusoid in that frequency.

One of the key representations/requirements of the math is that integration is done from <m>{-infty}</m> to <m>{+infty}</m> time units (seconds, days, months, years, etc), and that the function <m>f(t)</m> is continuous (no abrupt changes in value, or discontinuities). Things can change rapidly, but a function is only continuous if arbitrarily small changes in its value can be assured by restricting to sufficiently small changes of its argument.

The [[wp>discrete Fourier transform]] transforms a sequence of N complex numbers representing time domain data (such as <m>delim{lbrace}{x_n}{rbrace} = x_0, x_1, ..., x_{N-1}</m> into another sequence of complex numbers representing frequency domain data (such as <m>delim{lbrace}{X_k}{rbrace} = X_0, X_1, ..., X_{N-1}</m> and is defined by:

<m>X_k = sum{n = 0}{N -1}{x_n e^{{2 pi i k}/{N}}}</m>

For those what want to understand what is really going on in a very intuative description, spend the 20 min and watch the video by [[https://www.3blue1brown.com/|Grant Sanderson]] on his excellent [[https://www.youtube.com/3Blue1Brown|3Blue1Brown]] Youtube channel, which describes this in a very initiative, math-light methodology (which some prefer).

{{youtube>spUNpyF58BY?500}}

However - even when using modern algorithms like the [[wp>Fast Fourier transform]] are used, those tenets still apply:
  * the input is an infinite, continuous, complex valued time series
  * the output is an infinite, continuous, complex valued frequency series

If you are capturing a sine wave on a converter, it's important to make sure you understand how the FFT/DFT is working, since it can dramatically effect the output. The easiest way to understand things, is to work through an example. Although the numbers may seem arbitrary - they are based on prime numbers to keep things as uncorrelated as possible. 

Sampling a complex 1.304639 MHz sine way at 11.503888 MSPS, on a 12-bit converter gives us this data:

{{:resources:tools-software:linux-software:iio_oscilloscope:64-samples.png?600|}}

And if we look at the FFT of that we get:

{{:resources:tools-software:linux-software:iio_oscilloscope:64_fft_rect_line.png?600|}}

If we try to look at the points only, to better understand what's going on, it's just as puzzling. We are only putting in a single size wave, but we clearly see the DFT thinks there is more than one, and there is lots of noise everywhere (the noise floor of -38 dB is only ~6 ENOB((Effective number of bits)) of dynamic range - so we need to understand what is going on..

{{:resources:tools-software:linux-software:iio_oscilloscope:64_fft_rect.png?700|}}

which is actually pretty terrible performance. What we forgot is that the DFT thinks that the data is:
  * the input is an infinite, continuous, complex valued time series
  * the output is an infinite, continuous, complex valued frequency series

If we think of the data like that - we can clearly see that there is a giant discontinuity between repeating buffers.

{{:resources:tools-software:linux-software:iio_oscilloscope:repeated-64-samples.png?800|}}

So, we need a way to remove the discontinuous samples at the start and the end of the function. A simple way to do that is to use coherent sampling, and ensure that we only have full sine waves in our buffer. This would limit the measurements to integers of sample rate divided by the number of samples we are taking.

<m>F_{measured} = k {Sample Rate}/N_{Samples}</m>

In this case, of sampling a complex 2.5 MHz sine way at 10 MSPS, using 64-points (exactly 4 samples per full sine wave cycle, 16-waveforms per capture, where the   on a 12-bit converter gives us this data (in the time and frequency domain).

{{:resources:tools-software:linux-software:iio_oscilloscope:64_coherent_time.png?420|}} {{:resources:tools-software:linux-software:iio_oscilloscope:64_coherent_fft.png?420|}}

While this does improve the results (our noise floor is now ~ -85 dBFS, or an ENOB of greater than 12-bits). Sampling everything coherently would severely limit the practical effectiveness using the DFT to analyze unknown signals / spectrum.

Reverting back to our previous example of capturing a complex 1.304639 MHz sine way at 11.503888 MSPS, on a 12-bit converter, we need to have some way of reducing the discontinuities between buffers/samples. A way to do this would be to pass the data through a "window" function before computing the DFT to manipulate the data, and eliminate the possibility of discontinuities at the start/ends of the samples. A simple Window function is the "Triangle Window", 

{{:resources:tools-software:linux-software:iio_oscilloscope:64_triangle_time.png?420|}} {{:resources:tools-software:linux-software:iio_oscilloscope:64_triangle_fft.png?420|}}

This improves our results, but also changes the DFT results, so we need to understand what's happening in the math to ensure we don't misinterpret the changes we are making. What we have done is added a window function <m>w(t)</m> into the FFT equation.

<m>Result = int{-infty}{+infty}{w(t) x(t) e^{-2 pi i omega t} dt}</m>

Multiplication in the time domain is [[wp>Convolution_theorem|convolution]] in the frequency domain (where the '∗' symbol is the convolution operator):

<m>Result = W(omega)</m>∗<m>X(omega) =  int{-infty}{+infty}{w(t) x(t) e^{-2 pi i omega t} dt}</m>

This is why it is critical to understand both the time domain and frequency domain changes that might occur from applying a specific window function.


====== Choosing a Window Function ======

A [[wp>Window_function|window function]] is a mathematical function that is normally symmetric around the middle of the interval, usually near a maximum in the middle, and usually tapering away from the middle. 

Each [[wp>Window_function|window function]] has its own characteristics and suitability for different applications (some are more frequency accurate, others are more amplitude accurate). To choose a window function, you (the user) must select the most appropriate one. Some suggestions:

  * Sine wave or combination of sine waves: Hann
  * Sine wave (amplitude accuracy is important): Flat Top
  * Narrowband random signal (vibration data): Hann
  * Broadband random (white noise): Rectangular
  * Closely spaced sine waves: Uniform, Hamming
  * Excitation signals (hammer blow): Force
  * Response signals: Exponential
  * Unknown content: Hann
  * Two tones with frequencies close but amplitudes very different: Kaiser-Bessel
  * Two tones with frequencies close and almost equal amplitudes: Rectangular


===== Hann Window =====
[[wp>/Hann_function|Hann]] (also known as Hanning, raised cosine, or von Hann) window, is named after the Austrian meteorologist [[wp>Julius_von_Hann|Julius von Hann]]. The math looks like:

<m>w[n] = 1/2(1 - cos({2 pi n}/N))</m>

{{:resources:tools-software:linux-software:iio_oscilloscope:window_function-hann.png?400|}}

===== Rectangular window =====

The rectangular window (also known as as boxcar, uniform or Dirichlet window) is the simplest window, equivalent to replacing all but N values of a data sequence by zeros, making it appear as though the waveform suddenly turns on and off.

<m>w[n] = 1</m>

{{:resources:tools-software:linux-software:iio_oscilloscope:window_function-rectangular.png?400|}}

===== Triangular =====

Triangular windows are given by:

<m>w[n] = 1 - delim{|}{{n - N/2}/{N/2}}{|}</m>

{{:resources:tools-software:linux-software:iio_oscilloscope:window_function-triangular.png?400|}}

===== Welch =====

The Welch window consists of a single parabolic section:

<m>w[n] = 1 - ({n - {N/2}}/{N/2})^2</m>

{{:resources:tools-software:linux-software:iio_oscilloscope:window_function-welch.png?400|}}

===== Blackman =====

General purpose Blackman windows are defined as:

<m>w[n] = a_{0} - a_{1}cos({2 pi n}/N) + a_{2}cos({4 pi n}/N)</m>

The version that we implement is known as the //Exact Blackman// and uses:
  * <m>a_{0} = 7938/18608</m>
  * <m>a_{1} = 9240/18608</m>
  * <m>a_{2} = 1430/18608</m>

{{:resources:tools-software:linux-software:iio_oscilloscope:window_function-blackman.png?400|}}

===== Cosine =====
The cosine window is also known as the sine window, as it represents half a cycle of a sinusoidal function, 

<m>w[n] = cos({pi n}/{N} - pi/2) = sin({pi n}/{N})</m>

{{:resources:tools-software:linux-software:iio_oscilloscope:window_function-cosine.png?400|}}

===== Hamming =====

===== Chebyshev =====

===== Kaiser =====

===== Blackman-Harris =====

===== Flat Top =====

===== 3 Term Cosine =====

===== 4 Term Cosine =====

===== 5 Term Cosine =====

===== 6 Term Cosine =====

===== 7 Term Cosine =====
Analog Devices Wiki

Page Tools
