Building a Signal Processing Script in MATLAB

Analogy categoryAnalogies

Signal processing is one of MATLAB's strongest domains, combining native array math with the Signal Processing Toolbox's filter design and spectral-analysis functions. A typical script follows a clear pipeline: generate or import a signal, inspect it in the time domain, design and apply a filter to remove unwanted frequency content, then analyze the result in the frequency domain to confirm the filter worked. Building this pipeline from scratch, rather than calling a single black-box function, is the best way to understand what each stage of a real signal chain, from an ECG monitor to a radio receiver, is actually doing to the data.

🏏

Cricket analogy: A bowling coach breaks down a delivery into a clear sequence, run-up, load-up, release, follow-through, rather than judging the ball as one opaque event, similar to building a signal-processing script stage by stage instead of calling one black-box function.

Generating and Visualizing a Signal

The pipeline starts by constructing a time vector and a signal built from known components, which lets you verify each later stage against ground truth. Using t = 0:1/Fs:1-1/Fs creates one second of samples at sampling rate Fs, and a composite signal like x = sin(2*pi*50*t) + sin(2*pi*120*t) plus noise simulates a real sensor reading with a genuine low-frequency component buried under interference. Plotting with plot(t, x) confirms the waveform looks as expected before any processing begins; skipping this visual sanity check is one of the most common reasons a bug several stages later turns out to have been present in the input signal all along.

🏏

Cricket analogy: A batting coach checks a player's stance and grip on camera before analyzing their shot-making, since a flaw in the setup would corrupt everything that follows, similar to plotting a raw signal with plot(t,x) before applying any filtering in MATLAB.

matlab

% Stage 1: Generate a composite signal: a 50 Hz true component plus
% a 120 Hz interference component plus random noise
Fs = 1000;                       % sampling frequency (Hz)
t  = 0:1/Fs:1-1/Fs;              % one second of samples
x  = sin(2*pi*50*t) + sin(2*pi*120*t) + 0.2*randn(size(t));

figure; plot(t, x); xlabel('Time (s)'); ylabel('Amplitude');
title('Raw noisy signal');

% Stage 2: Design and apply a low-pass Butterworth filter to remove
% the 120 Hz interference while keeping the 50 Hz component
cutoff = 80;                     % Hz
[b, a] = butter(4, cutoff/(Fs/2), 'low');
x_filtered = filtfilt(b, a, x);  % zero-phase filtering

figure; plot(t, x, t, x_filtered);
legend('Original', 'Filtered'); xlabel('Time (s)');
title('Signal before and after low-pass filtering');

Frequency Domain Verification with FFT

Once the filter is applied, the frequency domain confirms whether it actually worked. Taking Y = fft(x) and plotting the magnitude against a frequency axis built from f = (0:length(x)-1)*(Fs/length(x)) reveals the peaks corresponding to each sinusoidal component in the original signal; a well-designed low-pass filter should show the 120 Hz peak sharply attenuated while the 50 Hz peak remains close to full amplitude. Using filtfilt instead of filter is deliberate: filtfilt applies the filter forward and backward, canceling out the phase distortion a single-pass IIR filter would otherwise introduce, which matters whenever the timing of features in the signal, not just their amplitude, is important.

🏏

Cricket analogy: A ball-tracking system's Hawk-Eye analysis breaks a delivery's trajectory into its component speed and swing to see exactly what changed after a bowler tweaks their grip, similar to using an FFT in MATLAB to see which frequency components a filter actually removed.

Using filter() instead of filtfilt() on a signal where timing matters (like an ECG R-wave or an audio transient) will shift features in time due to the filter's phase response, even though the frequency content looks correct. filtfilt() runs the filter twice (forward and backward) to cancel phase distortion at the cost of roughly double the computation and the requirement that the filter be stable and applied offline (it cannot be used in real-time streaming applications).

A signal-processing script follows a clear pipeline: generate/import the signal, inspect it in the time domain, filter it, then verify in the frequency domain.
Always plot the raw signal with plot(t, x) before processing, since bugs discovered late are often actually present in the input.
butter(order, cutoff/(Fs/2), 'low') designs a Butterworth low-pass filter; the cutoff must be normalized to the Nyquist frequency (Fs/2).
filtfilt() applies a filter forward and backward to eliminate phase distortion, at roughly double the computational cost of filter().
fft(x) transforms a time-domain signal into the frequency domain; its magnitude spectrum reveals which frequency components are present.
The frequency axis for an FFT plot is built as f = (0:length(x)-1)*(Fs/length(x)), which spans from 0 up to just below Fs.
Comparing FFT magnitude before and after filtering is the standard way to confirm a filter removed the intended frequency content.