Why frequency analysis matters in Signal Processing

Introduction

Frequency analysis helps us understand the hidden patterns in signals by breaking them into simple waves. This makes it easier to study and use signals in real life.

To find the main tones in a piece of music.

To detect faults in machines by analyzing vibration signals.

To improve voice clarity in phone calls.

To analyze heartbeats in medical devices.

To filter out noise from sensor data.

Syntax

Signal Processing

frequency_spectrum = FourierTransform(signal)

The Fourier Transform converts a signal from time to frequency.

This helps us see which frequencies are strong or weak in the signal.

Examples

This code finds the frequency content of a 5 Hz sine wave.

Signal Processing

import numpy as np
fs = 100
T = 1
t = np.linspace(0, T, fs, endpoint=False)
signal = np.sin(2 * np.pi * 5 * t)  # 5 Hz sine wave
spectrum = np.fft.fft(signal)

This code finds frequencies in a signal made of 5 Hz and 10 Hz waves.

Signal Processing

import numpy as np
fs = 100
T = 1
t = np.linspace(0, T, fs, endpoint=False)
signal = np.sin(2 * np.pi * 5 * t) + np.sin(2 * np.pi * 10 * t)
spectrum = np.fft.fft(signal)

Sample Program

This program creates a signal with two frequencies, finds their strengths using frequency analysis, and shows the results.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

# Create a signal with two frequencies: 5 Hz and 10 Hz
fs = 100  # Sampling rate in Hz
T = 1     # Duration in seconds
t = np.linspace(0, T, fs, endpoint=False)
signal = np.sin(2 * np.pi * 5 * t) + 0.5 * np.sin(2 * np.pi * 10 * t)

# Compute the frequency spectrum
spectrum = np.fft.fft(signal)
freq = np.fft.fftfreq(len(signal), 1/fs)

# Take only the positive half of frequencies and spectrum
pos_mask = freq >= 0
freq = freq[pos_mask]
spectrum = np.abs(spectrum[pos_mask])

# Print main frequencies and their strengths
for f, amp in zip(freq, spectrum):
    if amp > 10:
        print(f"Frequency: {f:.1f} Hz, Amplitude: {amp:.1f}")

# Plot the frequency spectrum
plt.stem(freq, spectrum, use_line_collection=True)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude')
plt.title('Frequency Spectrum')
plt.show()

Important Notes

Frequency analysis works best with signals sampled evenly over time.

Higher amplitude in the spectrum means stronger presence of that frequency.

Negative frequencies appear due to math but usually we focus on positive ones.

Summary

Frequency analysis breaks signals into simple waves to find hidden patterns.

It helps in many real-life tasks like music, medicine, and machine monitoring.

Using tools like Fourier Transform, we can see which frequencies are in a signal.

Practice

1. Why is frequency analysis important in signal processing?

easy

A. It increases the signal's volume.

B. It helps identify hidden patterns by breaking signals into simple waves.

C. It changes the signal's color.

D. It removes all noise from the signal automatically.

Solution

1. Step 1: Understand the purpose of frequency analysis

   Frequency analysis breaks complex signals into simpler parts called frequencies to reveal hidden patterns.

2. Step 2: Compare options to the purpose

   Only It helps identify hidden patterns by breaking signals into simple waves. correctly states this purpose. Other options describe unrelated or incorrect effects.

3. Final Answer:

   It helps identify hidden patterns by breaking signals into simple waves. -> Option B

4. Quick Check:

   Frequency analysis = reveals hidden patterns [OK]

Hint: Frequency analysis reveals hidden waves in signals [OK]

Common Mistakes:

• Thinking frequency analysis changes signal volume
• Believing it changes signal color
• Assuming it removes noise automatically

2. Which of the following is the correct way to represent a Fourier Transform in Python using numpy?

easy

A. np.fft.fft(signal)

B. np.fft.transform(signal)

C. np.fft.fourier(signal)

D. np.fft.frequency(signal)

Solution

1. Step 1: Recall numpy FFT function name

   The numpy library uses np.fft.fft() to compute the Fourier Transform of a signal.

2. Step 2: Check each option's correctness

   Only np.fft.fft(signal) uses the correct function name. Others are invalid or do not exist in numpy.

3. Final Answer:

   np.fft.fft(signal) -> Option A

4. Quick Check:

   Correct numpy FFT function = np.fft.fft() [OK]

Hint: Remember numpy FFT is np.fft.fft() [OK]

Common Mistakes:

• Using incorrect function names like transform or fourier
• Confusing frequency with fft function
• Misspelling numpy function names

3. Given the Python code:

import numpy as np
signal = np.array([1, 0, -1, 0])
freqs = np.fft.fft(signal)
print(np.round(freqs, 2))

What is the output?

medium

A. [0.+0.j 0.+2.j 0.+0.j 0.-2.j]

B. [0.+0.j 0.+0.j 0.+0.j 0.+0.j]

C. [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

D. [0.+0.j 1.+0.j 0.+0.j 1.+0.j]

Solution

1. Step 1: Compute FFT of the signal

   The signal [1, 0, -1, 0] represents a sine wave pattern, not a pure cosine wave. Its FFT results in imaginary components at certain frequencies.

2. Step 2: Interpret FFT output

   The FFT output rounded to 2 decimals is [0.+0.j 0.+2.j 0.+0.j 0.-2.j], showing imaginary parts at k=1 and k=3.

3. Final Answer:

   [0.+0.j 0.+2.j 0.+0.j 0.-2.j] -> Option A

4. Quick Check:

   FFT output matches imaginary sine components [OK]

Hint: FFT of sine-like signals has imaginary parts [OK]

Common Mistakes:

• Mistaking sine for cosine, expecting real parts
• Confusing magnitude with raw FFT values
• Assuming FFT output is always real

4. The following code tries to compute the frequency components but gives an error:

import numpy as np
signal = [1, 2, 3, 4]
freqs = np.fft.fft(signal)
print(freqs)

What is the error and how to fix it?

medium

A. Error because np.fft.fft requires integer input only.

B. Error because signal is a list, convert it to numpy array first.

C. Error because np.fft.fft is misspelled.

D. No error; code runs fine.

Solution

1. Step 1: Check input type for np.fft.fft

   np.fft.fft accepts lists or numpy arrays as input and converts lists internally.

2. Step 2: Verify code correctness

   The code runs without error and prints the FFT of the list signal.

3. Final Answer:

   No error; code runs fine. -> Option D

4. Quick Check:

   np.fft.fft accepts lists directly [OK]

Hint: np.fft.fft works with lists or arrays [OK]

Common Mistakes:

• Assuming lists cause errors in FFT
• Thinking FFT input must be integers only
• Believing function name is misspelled

5. You have a machine vibration signal sampled at 1000 Hz. You want to find if a fault frequency of 50 Hz is present. Which step is best to detect this using frequency analysis?

hard

A. Filter out frequencies below 100 Hz only.

B. Increase the signal amplitude and listen to it.

C. Apply Fourier Transform and check magnitude at 50 Hz frequency bin.

D. Use time domain average without frequency analysis.

Solution

1. Step 1: Understand the goal

   We want to detect if 50 Hz frequency exists in the vibration signal.

2. Step 2: Use Fourier Transform to analyze frequencies

   Applying Fourier Transform converts the signal to frequency domain, allowing us to check magnitude at 50 Hz.

3. Step 3: Interpret frequency bin

   By examining the magnitude at the 50 Hz bin, we can confirm presence or absence of the fault frequency.

4. Final Answer:

   Apply Fourier Transform and check magnitude at 50 Hz frequency bin. -> Option C

5. Quick Check:

   Fourier Transform reveals specific frequencies [OK]

Hint: Check frequency magnitude at target frequency after FFT [OK]

Common Mistakes:

• Ignoring frequency domain and using time domain only
• Filtering wrong frequency ranges
• Assuming amplitude increase reveals frequency