Applied Mathematics for Engineering

7. Fourier Analysis and Signal Processing

Fourier analysis is a fundamental technique in signal processing, which plays a critical role in mechatronics engineering. This article will explore the concepts of Fourier series, Fourier transform, and Laplace transform, as well as their applications in filtering and control systems. We will also provide examples of how Python’s SciPy and NumPy libraries can be utilized to perform Fourier analysis and design filters.

7.1. Fourier Series

A Fourier series is a way to represent a periodic function as the sum of an infinite series of sinusoids (sine and cosine functions). This representation is particularly useful in mechatronics because many signals in real-world systems are periodic in nature, such as the output of a sensor or the oscillation of a mechanical system.

The complex exponential Fourier series of a periodic function f(t) with period T is given by:

\[\sum_{n=-\infty}^{\infty} c_n e^{j\frac{2\pi nt}{T}}\]

where \(c_n\) are the complex Fourier coefficients, and can be calculated using:

\[c_n = \frac{1}{T} \int_{0}^{T} f(t) e^{-j\frac{2\pi nt}{T}} dt\]

An alternative representation of the Fourier series uses trigonometric functions:

\[f(t) = a_0 + \sum_{n=1}^{\infty} [a_n \cos(2\pi nf_0 t) + b_n \sin(2\pi nf_0 t)]\]

Both forms are related through Euler’s formula and can be used for different purposes. The complex exponential form simplifies the mathematics involved in many signal processing and analysis tasks, while the trigonometric form provides a more intuitive understanding of the frequency components' amplitude and phase relationships.

The Fourier series is often used to analyze periodic signals, such as vibrations in mechanical systems or electrical waveforms in power systems. Understanding the frequency components of these signals can help engineers:

Design filters to reduce noise or unwanted vibrations
Diagnose problems in rotating machinery by analyzing the harmonics in vibration signals
Optimize the performance of mechatronic systems by analyzing and controlling periodic disturbances

In mechatronics, the Fourier series can be used to analyze the frequency components of a periodic signal, such as vibrations in mechanical systems or electrical waveforms in power electronics. This analysis can help engineers identify the primary frequencies causing unwanted oscillations, which can then be addressed through mechanical design or control algorithms.

7.2. Fourier Transform

The Fourier transform is an extension of the Fourier series to non-periodic functions, allowing for the analysis of a wider range of signals. The Fourier transform of a continuous-time function f(t) is given by:

\[F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-j\omega t} dt\]

And the inverse Fourier transform is given by:

\[f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega) e^{j\omega t} d\omega\]

The Fourier transform is useful for analyzing non-periodic signals and understanding the frequency content of a wide range of signals. This can be helpful in various engineering applications, such as:

Signal processing: Filtering, compression, and denoising of audio, image, or communication signals
Spectrum analysis: Identifying the frequency components of an unknown signal, which can be useful for troubleshooting or diagnostics
Control systems: Designing feedback controllers for mechatronics systems based on the frequency response of the system

In mechatronics, the Fourier transform is useful for analyzing non-periodic signals, such as transient responses of mechanical systems or electrical signals in communication systems. It can also be used to design filters and control systems in the frequency domain, providing insight into the system’s behavior at different frequencies.

7.3. Laplace Transform

The Laplace transform is another powerful tool for analyzing signals and systems in the frequency domain. While the Fourier transform deals with sinusoidal functions, the Laplace transform is more general and can handle a broader range of functions, including those with exponential growth or decay.

The Laplace transform of a continuous-time function f(t) is given by:

\[F(s) = \int_{0}^{\infty} f(t) e^{-st} dt\]

The Laplace transform has several practical applications in engineering, particularly in the analysis and design of control systems. Some examples include:

System modeling: The Laplace transform helps derive transfer functions for linear time-invariant (LTI) systems, which are essential for understanding the system’s behavior and designing appropriate controllers
Stability analysis: Using the Laplace transform, engineers can analyze the poles of a system to determine its stability and transient response
Control system design: The Laplace domain simplifies the design and analysis of feedback controllers, such as PID controllers, for various engineering systems

The Laplace transform is particularly useful in mechatronics for analyzing and designing control systems, as it can help engineers understand the stability and transient behavior of a system. It can also be used to derive transfer functions, which are crucial for designing controllers in the frequency domain.

7.4. Filtering Noisy Sensor Data

Let’s consider a practical example in mechatronics: filtering noisy sensor data. We can use Python’s SciPy and NumPy libraries to perform Fourier analysis and design filters. Here’s a simple example:

import numpy as np
import scipy.signal
import matplotlib.pyplot as plt
Simulate noisy sensor data

t = np.linspace(0, 1, 1000)
signal = np.sin(2 * np.pi * 5 * t) # 5 Hz sine wave
noise = np.random.normal(0, 0.5, len(t)) # Gaussian noise
noisy_signal = signal + noise
Design a Butterworth low-pass filter

cutoff_freq = 10 # Hz
nyquist_freq = 0.5 * len(t)
normalized_cutoff = cutoff_freq / nyquist_freq
b, a = scipy.signal.butter(2, normalized_cutoff, btype='low')
Apply the filter to the noisy signal

filtered_signal = scipy.signal.lfilter(b, a, noisy_signal)
Plot the original, noisy, and filtered signals
plt.figure(figsize=(12, 6))
plt.plot(t, signal, label='Original Signal')
plt.plot(t, noisy_signal, label='Noisy Signal')
plt.plot(t, filtered_signal, label='Filtered Signal')
plt.legend()
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.title('Filtering Noisy Sensor Data')
plt.show()

In this example, we first simulate a noisy sensor signal by adding Gaussian noise to a 5 Hz sine wave. We then design a Butterworth low-pass filter with a cutoff frequency of 10 Hz and apply it to the noisy signal. The result is a filtered signal that closely resembles the original, noise-free signal.

7.5. Exercise

Example 1

What are the main differences between the Fourier series, Fourier transform, and Laplace transform? Can you provide equations and a short Python program that demonstrates these concepts?

Solution:

The main differences between the Fourier series, Fourier transform, and Laplace transform are:

Fourier series: Represents periodic functions as the sum of an infinite series of sinusoids (sine and cosine functions). It is mainly used for analyzing periodic signals in mechatronics systems. The Fourier series equation is:

\[f(t) = a_0 + \sum_{n=1}^{\infty} [a_n \cos(2\pi nf_0 t) + b_n \sin(2\pi nf_0 t)]\]

Fourier transform: Extends the Fourier series to non-periodic functions, allowing for the analysis of a wider range of signals. It is useful for analyzing non-periodic signals and designing filters and control systems in the frequency domain. The Fourier transform equation is:

\[F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-j\omega t} , dt\]

Laplace transform: A more general transform that can handle a broader range of functions, including those with exponential growth or decay. It is particularly useful for analyzing and designing control systems, understanding the stability and transient behaviour of a system, and deriving transfer functions. The Laplace transform equation is:

\[F(s) = \int_{0}^{\infty} f(t) e^{-st} , dt\]

Here is a complete Python program that demonstrates the differences between the Fourier series, Fourier transform, and Laplace transform using a square wave signal as an example:

import numpy as np
import matplotlib.pyplot as plt
from scipy.fft import fft
from scipy.signal import square
from scipy.integrate import odeint

# Fourier Series
def square_wave_fourier_series(t, n_terms):
    result = 0
    for n in range(1, n_terms + 1, 2):
        term = (1/n) * np.sin(2 * np.pi * n * t)
        result += term
    return (4/np.pi) * result

# Fourier Transform
def plot_fft(t, signal, title):
    X = fft(signal)
    freqs = np.fft.fftfreq(len(t), t[1] - t[0])
    plt.plot(freqs, np.abs(X))
    plt.title(title)
    plt.xlabel("Frequency [Hz]")
    plt.ylabel("Magnitude")
    plt.xlim(0, 15)
    plt.grid()

# Laplace Transform - first-order system example
def first_order_system(y, t, K, tau):
    dydt = (-y + K) / tau
    return dydt

# Time domain
t = np.linspace(0, 2, 1000)
square_wave = square(2 * np.pi * t)

# Fourier series example
n_terms = 10
square_wave_approx = square_wave_fourier_series(t, n_terms)

# Fourier transform example
plot_fft(t, square_wave, "Fourier Transform of a Square Wave")

# Laplace transform example - first-order system response
K = 1
tau = 0.5
response = odeint(first_order_system, 0, t, args=(K, tau))

# Plot results
fig, axs = plt.subplots(3, 1, figsize=(8, 12))
axs[0].plot(t, square_wave, label="Square Wave")
axs[0].plot(t, square_wave_approx, label=f"Fourier Series ({n_terms} terms)")
axs[0].set_title("Fourier Series")
axs[0].set_xlabel("Time [s]")
axs[0].set_ylabel("Amplitude")
axs[0].legend()
axs[0].grid()

axs[1].plot(t, square_wave, label="Square Wave")
plot_fft(t, square_wave, "Fourier Transform of a Square Wave")
axs[1].set_title("Fourier Transform")
axs[1].set_xlabel("Frequency [Hz]")
axs[1].set_ylabel("Magnitude")
axs[1].set_xlim(0, 15)
axs[1].grid()

axs[2].plot(t, response, label="First-order System Response")
axs[2].set_title("Laplace Transform (First-order System Example)")
axs[2].set_xlabel("Time [s]")
axs[2].set_ylabel("Amplitude")
axs[2].legend()
axs[2].grid()

plt.tight_layout()
plt.show()

This program demonstrates the differences between the Fourier series, Fourier transform, and Laplace transform using a square wave signal. The Fourier series is shown approximating the square wave with 10 terms, while the Fourier transform is used to analyze the frequency components of the square wave. Finally, the Laplace transform is demonstrated using a first-order system’s step response, which is a common application in control systems.

Example 2

How can the Fourier transform be used to analyze the frequency components of a non-periodic signal in a mechatronics system? Can you provide a short Python program that demonstrates this?

Solution:

The Fourier transform can be used to analyze the frequency components of a non-periodic signal in a mechatronics system by transforming the time-domain signal into the frequency domain. This provides insight into the system’s behavior at different frequencies, allowing engineers to identify critical frequencies and design appropriate filters or control algorithms to address them. Here is a short Python program that demonstrates this using the Fast Fourier Transform (FFT) function from the numpy library:

import numpy as np
import matplotlib.pyplot as plt

# Define the non-periodic signal
def signal(t):
    return np.sin(2 * np.pi * 5 * t) + np.cos(2 * np.pi * 10 * t)

# Generate the time-domain signal
sampling_rate = 1000
t = np.linspace(0, 1, sampling_rate)
x = signal(t)

# Perform the Fast Fourier Transform (FFT)
X = np.fft.fft(x)
freqs = np.fft.fftfreq(sampling_rate, 1/sampling_rate)

# Plot the time-domain and frequency-domain signals
fig, (ax1, ax2) = plt.subplots(2, 1)
ax1.plot(t, x)
ax1.set_title("Time Domain Signal")
ax1.set_xlabel("Time [s]")
ax1.set_ylabel("Amplitude")

ax2.plot(freqs, np.abs(X))
ax2.set_title("Frequency Domain Signal")
ax2.set_xlabel("Frequency [Hz]")
ax2.set_ylabel("Magnitude")
ax2.set_xlim(0, 50)

plt.tight_layout()
plt.show()

This Python program generates a non-periodic signal composed of two sinusoids with different frequencies. It then uses the Fast Fourier Transform (FFT) from the numpy library to convert the time-domain signal into the frequency domain, which can be used to analyze the system’s behavior at different frequencies. The program also plots both the time-domain and frequency-domain signals for visualization purposes.

Example 3

Consider a mechatronics system with a transfer function H(s). Write a Python program to find the step response of the system using the inverse Laplace transform.

Solution:

Here’s a Python program to find the step response of a mechatronics system with a transfer function H(s) using the inverse Laplace transform:

import numpy as np
import scipy.signal
import matplotlib.pyplot as plt
from sympy import symbols, laplace_transform, inverse_laplace_transform, Heaviside
Define the transfer function H(s)

s = symbols('s')
H = 1 / (s**2 + 2*s + 5)
Find the inverse Laplace transform of H(s) * 1/s

t = symbols('t', positive=True)
step_response = inverse_laplace_transform(H * 1/s, s, t).subs(Heaviside(t), 1)
Plot the step response

t_vals = np.linspace(0, 10, 1000)
step_response_vals = [step_response.subs(t, t_val).evalf() for t_val in t_vals]
plt.figure(figsize=(12, 6))
plt.plot(t_vals, step_response_vals)
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.title('Step Response of the System')
plt.show()

Example 4

Using the Python example provided, modify the code to filter a noisy signal with a high-pass filter instead of a low-pass filter.

Solution:

To modify the provided Python example to filter a noisy signal with a high-pass filter instead of a low-pass filter, change the filter design and update the filter type:

import numpy as np
import scipy.signal
import matplotlib.pyplot as plt
Simulate noisy sensor data

t = np.linspace(0, 1, 1000)
signal = np.sin(2 * np.pi * 5 * t) # 5 Hz sine wave
noise = np.random.normal(0, 0.5, len(t)) # Gaussian noise
noisy_signal = signal + noise
Design a Butterworth high-pass filter

cutoff_freq = 10 # Hz
nyquist_freq = 0.5 * len(t)
normalized_cutoff = cutoff_freq / nyquist_freq
b, a = scipy.signal.butter(2, normalized_cutoff, btype='high')
Apply the filter to the noisy signal

filtered_signal = scipy.signal.lfilter(b, a, noisy_signal)
Plot the original, noisy, and filtered signals

plt.figure(figsize=(12, 6))
plt.plot(t, signal, label='Original Signal')
plt.plot(t, noisy_signal, label='Noisy Signal')
plt.plot(t, filtered_signal, label='Filtered Signal')
plt.legend()
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.title('Filtering Noisy Sensor Data with a High-Pass Filter')
plt.show()

In this modified example, we design a Butterworth high-pass filter with a cutoff frequency of 10 Hz and apply it to the noisy signal. The filtered signal will now emphasize the high-frequency components of the signal while attenuating the low-frequency components. This is useful in applications where high-frequency information is of interest, or when low-frequency noise needs to be removed.

Note that this specific example may not show a significant difference between the low-pass and high-pass filtered signals, as the original signal’s frequency (5 Hz) is below the chosen cutoff frequency (10 Hz). To see the high-pass filter in action, you can either increase the original signal’s frequency or decrease the cutoff frequency.

Applied Mathematics for Engineering

7. Fourier Analysis and Signal Processing

7.1. Fourier Series

7.2. Fourier Transform

7.3. Laplace Transform

7.4. Filtering Noisy Sensor Data

7.5. Exercise

Add Comment

Comments (1)