Frequency spectrum interpretation in Signal Processing

Introduction

Frequency spectrum interpretation helps us understand what frequencies make up a signal. It shows the strength of each frequency, like seeing the ingredients in a recipe.

To find the main tones in a music recording.

To detect faults in machines by analyzing vibration signals.

To analyze heartbeats in medical signals.

To improve wireless communication by studying signal frequencies.

To remove noise from audio recordings.

Syntax

Signal Processing

1. Obtain the signal data.
2. Apply a Fourier Transform (like FFT) to convert the signal from time to frequency.
3. Plot or analyze the magnitude of the frequency components.
4. Interpret peaks as dominant frequencies.

Fourier Transform changes a signal from time view to frequency view.

Peaks in the spectrum show strong frequencies present in the signal.

Examples

This example creates a signal with 50 Hz and 120 Hz tones, then shows their peaks in the frequency spectrum.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

# Create a signal with two frequencies
fs = 1000  # Sampling rate
T = 1.0    # seconds
t = np.linspace(0, T, int(fs*T), endpoint=False)
signal = 0.5*np.sin(2*np.pi*50*t) + 0.3*np.sin(2*np.pi*120*t)

# Compute FFT
fft_vals = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal), 1/fs)

# Plot magnitude spectrum
plt.plot(freqs[:len(freqs)//2], np.abs(fft_vals)[:len(fft_vals)//2])
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude')
plt.title('Frequency Spectrum')
plt.show()

This code finds the strongest frequency in the signal by locating the highest peak.

Signal Processing

# After FFT, find the frequency with the highest magnitude
peak_freq = freqs[np.argmax(np.abs(fft_vals))]
print(f"Dominant frequency: {abs(peak_freq):.1f} Hz")

Sample Program

This program creates a signal with two known frequencies, computes its frequency spectrum, prints the two strongest frequencies, and plots the spectrum.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

# Sampling parameters
fs = 500  # Sampling frequency in Hz
T = 2.0   # Duration in seconds

# Time array
t = np.linspace(0, T, int(fs*T), endpoint=False)

# Signal: sum of 60 Hz and 150 Hz sine waves
signal = 1.0*np.sin(2*np.pi*60*t) + 0.5*np.sin(2*np.pi*150*t)

# Compute FFT
fft_vals = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal), 1/fs)

# Only positive frequencies
pos_mask = freqs >= 0
freqs = freqs[pos_mask]
magnitudes = np.abs(fft_vals[pos_mask])

# Print dominant frequencies (top 2 peaks)
top_indices = magnitudes.argsort()[-2:][::-1]
for i in top_indices:
    print(f"Frequency: {freqs[i]:.1f} Hz, Magnitude: {magnitudes[i]:.2f}")

# Plot frequency spectrum
plt.plot(freqs, magnitudes)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude')
plt.title('Frequency Spectrum Interpretation')
plt.grid(True)
plt.show()

Important Notes

The frequency spectrum is symmetrical for real signals; usually, only positive frequencies are shown.

Magnitude shows how strong each frequency is in the signal.

Sampling rate limits the highest frequency you can detect (Nyquist frequency).

Summary

Frequency spectrum shows which frequencies are in a signal and how strong they are.

Use Fourier Transform to convert time signals to frequency signals.

Peaks in the spectrum tell you the main frequencies present.

Practice

1. What does a peak in a frequency spectrum represent in signal processing?

easy

A. A strong presence of a specific frequency in the signal

B. The time duration of the signal

C. The amplitude of the original time signal

D. The noise level in the signal

Solution

1. Step 1: Understand frequency spectrum meaning

   The frequency spectrum shows how much of each frequency is present in the signal.

2. Step 2: Interpret peaks in the spectrum

   A peak means that frequency has a strong presence or high amplitude in the signal.

3. Final Answer:

   A strong presence of a specific frequency in the signal -> Option A

4. Quick Check:

   Peak = strong frequency presence [OK]

Hint: Peaks show strong frequencies in the signal [OK]

Common Mistakes:

• Confusing time duration with frequency
• Thinking amplitude in time domain equals peak in spectrum
• Assuming noise causes peaks

2. Which of the following is the correct way to compute the frequency spectrum of a signal in Python using numpy?

easy

A. np.fft.freq(signal)

B. np.fft.ifft(signal)

C. np.fft.fft(signal)

D. np.fft.spectrum(signal)

Solution

1. Step 1: Recall numpy FFT functions

   np.fft.fft() computes the Fourier Transform to get frequency spectrum.

2. Step 2: Check other options

   np.fft.ifft() computes inverse FFT, others do not exist.

3. Final Answer:

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

4. Quick Check:

   FFT = np.fft.fft() [OK]

Hint: Use np.fft.fft() for frequency spectrum [OK]

Common Mistakes:

• Using inverse FFT instead of FFT
• Using non-existent numpy functions
• Confusing frequency and time domain functions

3. Given the Python code:

import numpy as np
signal = np.sin(2 * np.pi * 5 * np.linspace(0, 1, 100))
spectrum = np.fft.fft(signal)
peak_freq_index = np.argmax(np.abs(spectrum))
print(peak_freq_index)

What is the printed output?

medium

A. 50

B. 95

C. 0

D. 5

Solution

1. Step 1: Understand the signal frequency

   The signal is a sine wave at 5 Hz sampled 100 times over 1 second.

2. Step 2: Find peak frequency index in FFT

   FFT peak index corresponds to frequency 5, so index 5 is max magnitude.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Peak index = frequency = 5 [OK]

Hint: Peak index matches sine wave frequency [OK]

Common Mistakes:

• Confusing index with frequency value
• Ignoring sampling rate and length
• Mistaking negative frequency indices

4. The following code attempts to find the main frequency in a signal but gives wrong results:

import numpy as np
signal = np.sin(2 * np.pi * 10 * np.linspace(0, 1, 100))
spectrum = np.fft.fft(signal)
peak = np.argmax(spectrum)
print(peak)

What is the error?

medium

A. Using np.fft.fft instead of np.fft.ifft

B. Using np.argmax on complex spectrum instead of magnitude

C. Signal frequency is too high for sampling rate

D. Not normalizing the spectrum before argmax

Solution

1. Step 1: Check how peak is found

   np.argmax(spectrum) finds max of complex numbers, which is incorrect.

2. Step 2: Correct method to find peak

   Use np.argmax(np.abs(spectrum)) to find peak magnitude index.

3. Final Answer:

   Using np.argmax on complex spectrum instead of magnitude -> Option B

4. Quick Check:

   Peak must be on magnitude, not complex values [OK]

Hint: Use magnitude (abs) before argmax [OK]

Common Mistakes:

• Argmax on complex array directly
• Confusing FFT and IFFT
• Ignoring magnitude for peak detection

5. You have a signal composed of two sine waves at 3 Hz and 7 Hz sampled at 50 Hz for 2 seconds. Which code snippet correctly identifies both frequencies from the frequency spectrum?

hard

A. import numpy as np
t = np.linspace(0, 2, 100)
signal = np.sin(2*np.pi*3*t) + np.sin(2*np.pi*7*t)
spectrum = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(t), d=1/50)
peaks = freqs[np.argsort(np.abs(spectrum))[-2:]]
print(np.sort(np.abs(peaks)))

B. import numpy as np
t = np.linspace(0, 2, 100)
signal = np.sin(2*np.pi*3*t) + np.sin(2*np.pi*7*t)
spectrum = np.fft.ifft(signal)
freqs = np.fft.fftfreq(len(t), d=1/50)
peaks = freqs[np.argmax(np.abs(spectrum))]
print(peaks)

C. import numpy as np
t = np.linspace(0, 2, 50)
signal = np.sin(2*np.pi*3*t) + np.sin(2*np.pi*7*t)
spectrum = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(t), d=1/50)
peaks = freqs[np.argsort(np.abs(spectrum))[-2:]]
print(np.sort(np.abs(peaks)))

D. import numpy as np
t = np.linspace(0, 2, 100)
signal = np.sin(2*np.pi*3*t) + np.sin(2*np.pi*7*t)
spectrum = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(t), d=1/100)
peaks = freqs[np.argsort(np.abs(spectrum))[-2:]]
print(np.sort(np.abs(peaks)))

Solution

1. Step 1: Check sampling and signal length

   Sampling at 50 Hz for 2 seconds means 100 samples, so t has 100 points.

2. Step 2: Verify FFT and frequency calculation

   Use np.fft.fft(signal) and np.fft.fftfreq with d=1/50 for correct frequency bins.

3. Step 3: Identify two largest peaks

   Sort magnitudes and pick last two indices for peaks, then print sorted absolute frequencies.

4. Final Answer:

   Code snippet D correctly identifies both frequencies -> Option A

5. Quick Check:

   Correct sampling, FFT, freq bins, and peak selection [OK]

Hint: Match sample count and rate, use fftfreq with correct d [OK]

Common Mistakes:

• Using inverse FFT instead of FFT
• Wrong sample count or sampling interval
• Incorrect frequency bin calculation