1. Design and Evaluation of a Discrete Wavelet Transform based Multi-Signal Receiver using MATLAB
Advanced
Toolbox: Wavelet & Signal Processing
Deliverables: Code .m, Simulink Model, Full Report
🎯 Problem & Objective: General-purpose wideband receivers are designed to accept wide frequency spans, but typically capture strong interference along with desired signals. To boost signal detection capabilities, this project designs a dual-signal receiver where a secondary weak signal is detected in real time. A multi-resolution Discrete Wavelet Transform (DWT) module decomposes incoming wideband streams to suppress spurious spectral spikes and isolate simultaneous signals.
⚙️ Key MATLAB Functions:
wavedecwaverecdwtidwtwdenoisespectrogram
📊 Expected Output & Metrics: Multi-level wavelet approximation/detail decomposition trees (Daubechies db4), spur suppression ratio (>24 dB), weak signal extraction accuracy, and bit-error rate (BER) curves under varying SNR.
fs = 1e6; t = 0:1/fs:0.002;
s_strong = 2.0 * sin(2*pi*150e3*t);
s_weak = 0.25 * sin(2*pi*380e3*t);
spur_noise = 0.8 * sin(2*pi*220e3*t) + 0.3 * randn(size(t));
rx_signal = s_strong + s_weak + spur_noise;
wname = 'db4'; level = 4;
[C, L] = wavedec(rx_signal, level, wname);
thr = wthrmngr('dw2ddenoLVL', 'penalhi', C, L);
s_clean = wdencmp('lvd', rx_signal, wname, level, thr, 's');
figure;
subplot(2,1,1); plot(t*1e3, rx_signal, 'r'); title('Raw Multi-Signal with Strong RF Interference');
subplot(2,1,2); plot(t*1e3, s_clean, 'b', 'LineWidth', 1.2); title('DWT Decomposed & Reconstructed Output');
xlabel('Time (ms)');
Est. Duration: 2–3 Weeks
Request Custom Project →
2. Obstacle Recognition based on Machine Learning for On-Chip LiDAR Sensors in a Cyber-Physical System using MATLAB
Advanced
Toolbox: Lidar, Machine Learning & Simulink
Deliverables: Code .m, Co-simulation Framework, Full Report
🎯 Problem & Objective: Collision avoidance in advanced driver-assistance systems (ADAS) demands reliable real-time detection of vehicles, pedestrians, and static obstacles before imminent impacts. This project builds an obstacle recognition library in MATLAB/Simulink integrated with SCANeR software, extracting spatial signal features from on-chip LiDAR point clouds and classifying obstacles using trained ML models.
⚙️ Key MATLAB Functions:
pcreadpcsegdistfitcecocpredictbboxCameraToWorldpcshow
📊 Expected Output & Metrics: 3D LiDAR point cloud clustering, bounding box localization, confusion matrix showing classification accuracy (>96.5%), and latency benchmarks (<25 ms per frame).
ptCloud = pointCloud(10*rand(1000,3) .* [1 1 0.3]);
minDistance = 0.5;
[labels, numClusters] = pcsegdist(ptCloud, minDistance);
features = zeros(numClusters, 5);
for k = 1:numClusters
idx = find(labels == k);
clusterPts = ptCloud.Location(idx, :);
features(k, 1:3) = mean(clusterPts, 1);
features(k, 4) = max(pdist(clusterPts));
features(k, 5) = length(idx);
end
fprintf('Detected %d distinct obstacle clusters in LiDAR frame.\n', numClusters);
Est. Duration: 3–4 Weeks
Request Custom Project →
3. MATLAB/Simulink Implementation and Analysis of Three Pulse-Width-Modulation (PWM) Techniques
Intermediate
Toolbox: Simulink & Simscape Electrical
Deliverables: Code .m, .slx Model, THD Harmonic Report
🎯 Problem & Objective: In solid-state power electronic converters, three-phase Voltage Source Inverters (VSI) convert DC power to AC with variable magnitude and frequency. This project implements and compares Sinusoidal PWM (SPWM), Space Vector PWM (SVPWM), and Third-Harmonic Injection PWM (THIPWM) in MATLAB/Simulink to evaluate DC bus utilization, switching losses, and Total Harmonic Distortion (THD).
⚙️ Key MATLAB Functions:
simthdpower_analyzefftgensigsawtooth
📊 Expected Output & Metrics: FFT spectrum harmonic bars, line-to-line voltage waveforms, DC bus voltage utilization (+15.4% improvement in SVPWM), and THD comparisons (<5% for IEEE 519 compliance).
fs = 100000; t = 0:1/fs:0.04; f_mod = 50; f_carrier = 2000;
ma = 0.85;
v_carrier = sawtooth(2*pi*f_carrier*t, 0.5);
v_ref_spwm = ma * sin(2*pi*f_mod*t);
pwm_spwm = v_ref_spwm > v_carrier;
v_ref_thipwm = ma * (sin(2*pi*f_mod*t) + (1/6)*sin(6*pi*f_mod*t));
pwm_thipwm = v_ref_thipwm > v_carrier;
thd_spwm = thd(double(pwm_spwm), fs);
thd_thi = thd(double(pwm_thipwm), fs);
fprintf('SPWM THD: %.2f dB | THIPWM THD: %.2f dB\n', thd_spwm, thd_thi);
Est. Duration: 1–2 Weeks
Request Custom Project →
4. Detection of Breathing and Infant Sleep Apnea using MATLAB
Intermediate
Toolbox: Audio & Signal Processing
Deliverables: Code .m, Fixed-Point Algorithm, FPGA Porting Guide
🎯 Problem & Objective: Sleep apnea is a critical respiratory pause condition that poses severe mortality risks for premature neonates and infants. Traditional wired electrode monitoring disrupts sleep. This project develops a non-contact acoustic signal processing algorithm that continuously monitors breath sounds, calculates respiratory rates, and triggers real-time cessation alarm flags within 10 seconds of apnea onset.
⚙️ Key MATLAB Functions:
audioreadhilbertfindpeaksbutterenvelopespectrogram
📊 Expected Output & Metrics: Acoustic energy envelope waveforms, real-time breath-rate estimation (breaths/minute), apnea event alarm markers, and 98.2% detection sensitivity on benchmark neonate audio.
fs = 8000; t = 0:1/fs:30;
breath_pattern = (sin(2*pi*0.4*t) > 0) .* (t < 10 | t > 20);
acoustic_audio = breath_pattern .* (0.5*sin(2*pi*800*t) + 0.3*randn(size(t)));
[b, a] = butter(3, [200 1200]/(fs/2), 'bandpass');
filtered_audio = filtfilt(b, a, acoustic_audio);
analytic_env = abs(hilbert(filtered_audio));
smooth_env = movmean(analytic_env, fs*0.5);
is_apnea = smooth_env < 0.05;
figure;
plot(t, smooth_env, 'b', t, is_apnea*max(smooth_env), 'r--', 'LineWidth', 1.5);
legend('Respiratory Envelope', 'Apnea Alarm Trigger');
xlabel('Time (s)'); ylabel('Signal Amplitude');
Est. Duration: 1–2 Weeks
Request Custom Project →
5. Music Note Recognition and Fundamental Frequency Pitch Estimation using MATLAB
Beginner
Toolbox: Audio & Signal Processing
Deliverables: Code .m, GUI Note Identifier, Complete Report
🎯 Problem & Objective: Automatic music transcription requires estimating the fundamental frequency ($f_0$) of an audio stream and mapping it to chromatic musical scale notes (e.g., A4 = 440 Hz, C4 = 261.63 Hz). This project implements two approaches: time-domain autocorrelation/deviation analysis and Short-Time Fast Fourier Transformation (STFT) power spectrum peak picking to classify notes in real-time recorded audio (fs = 44,100 Hz).
⚙️ Key MATLAB Functions:
fftxcorrfindpeaksaudioreadpitchinterp1
📊 Expected Output & Metrics: Real-time FFT power spectrum display, detected peak fundamental frequency ($f_0$), exact musical note name output (C, D, E, F, G, A, B), and cent frequency deviation error (<2 Hz).
fs = 44100; t = 0:1/fs:0.8;
f_target = 440.0;
audio_sample = sin(2*pi*f_target*t) + 0.4*sin(2*pi*2*f_target*t) + 0.2*sin(2*pi*3*f_target*t);
N = length(audio_sample);
f_axis = (0:N/2-1)*(fs/N);
fft_mag = abs(fft(audio_sample.*hamming(N)')) / N;
half_mag = fft_mag(1:N/2);
[pks, locs] = findpeaks(half_mag, 'MinPeakHeight', 0.1);
f0_detected = f_axis(locs(1));
note_names = {'C','C#','D','D#','E','F','F#','G','G#','A','A#','B'};
midi_num = round(12 * log2(f0_detected / 440) + 69);
note_str = note_names{mod(midi_num, 12) + 1};
octave = floor(midi_num / 12) - 1;
fprintf('Detected Frequency: %.2f Hz -> Note: %s%d\n', f0_detected, note_str, octave);
Est. Duration: 6–8 Hours
Request Custom Project →
6. Interactive Graphical Continuous & Discrete Convolution Visualizer
Beginner
Toolbox: Signal Processing
Deliverables: Code .m, Interactive App, Video Demo
🎯 Problem & Objective: Convolution is often difficult for engineering students to conceptualize geometrically. This project creates an animated MATLAB script/App Designer GUI demonstrating the 4 fundamental stages of convolution: reflection ($h(-\tau)$), shifting ($h(t-\tau)$), overlapping multiplication ($x(\tau)h(t-\tau)$), and running integration/summation for arbitrary input signals.
⚙️ Key MATLAB Functions:
convtrapzstemanimatedlinedrawnowheaviside
📊 Expected Output & Metrics: Dynamic multi-panel animation showing overlapping integrand areas, commutative property verification $x*h = h*x$, and discrete stem convolution comparisons.
dt = 0.01; t = 0:dt:4;
x = (t >= 0.5 & t <= 2.0);
h = exp(-1.5*t);
y = conv(x, h) * dt;
t_y = 0:dt:(length(y)-1)*dt;
figure;
subplot(3,1,1); plot(t, x, 'b', 'LineWidth', 1.5); title('Input Signal x(t)'); grid on;
subplot(3,1,2); plot(t, h, 'r', 'LineWidth', 1.5); title('Impulse Response h(t)'); grid on;
subplot(3,1,3); plot(t_y, y, 'm', 'LineWidth', 2); title('Convolution Output y(t) = x(t) * h(t)'); grid on;
xlabel('Time (s)');
Est. Duration: 4–6 Hours
Request Custom Project →
7. Continuous-Time Fourier Series (CTFS) Synthesis & Gibbs Phenomenon Analysis
Beginner
Toolbox: Symbolic Math & Signal Processing
Deliverables: Code .m, Harmonic Convergence Report
🎯 Problem & Objective: Reconstruct periodic signals (square, triangular, and full-wave rectified waveforms) using trigonometric and exponential Fourier series. Quantify the 8.95% asymptotic peak overshoot (Gibbs phenomenon) occurring at jump discontinuities as the harmonic order $N \to \infty$.
⚙️ Key MATLAB Functions:
symsfourierintfplotsquaresawtooth
📊 Expected Output & Metrics: Harmonic superposition animations ($N=1, 3, 7, 25, 99$), harmonic amplitude decay rates ($1/n$ for square, $1/n^2$ for triangle), and overshoot percentage calculation.
t = -2:0.001:2; T0 = 2; w0 = 2*pi/T0;
N_terms = [1, 3, 9, 49];
figure;
for idx = 1:length(N_terms)
N = N_terms(idx);
y_approx = zeros(size(t));
for n = 1:2:N
bn = 4 / (n*pi);
y_approx = y_approx + bn * sin(n*w0*t);
end
subplot(2,2,idx);
plot(t, y_approx, 'b', t, square(w0*t), 'k--', 'LineWidth', 1.2);
title(sprintf('Fourier Synthesis (N = %d Harmonics)', N));
grid on; xlabel('Time (s)');
end
Est. Duration: 4–6 Hours
Request Custom Project →
8. Continuous-Time Fourier Transform (CTFT) & Spectral Energy Density
Intermediate
Toolbox: Symbolic Math & Signal Processing
Deliverables: Code .m, Symbolic Derivations, Spectral Plots
🎯 Problem & Objective: Analyze non-periodic aperiodic continuous-time signals (rectangular pulses, Gaussian pulses, damped exponentials) via the continuous-time Fourier transform. Verify transform duality, time-scaling/frequency-expansion theorems, and Parseval's energy conservation theorem $\int |x(t)|^2 dt = \frac{1}{2\pi}\int |X(\omega)|^2 d\omega$.
⚙️ Key MATLAB Functions:
fourierifouriersincintegralabsangle
📊 Expected Output & Metrics: Continuous magnitude/phase spectra $|X(j\omega)|$ and $\angle X(j\omega)$, energy spectral density curves, and Parseval identity verification with 0.00% numerical residual error.
syms t w a positive
x_sym = exp(-a*abs(t));
X_sym = fourier(x_sym, t, w);
a_val = 2;
E_time = integral(@(t) exp(-2*a_val*abs(t)), -Inf, Inf);
E_freq = (1/(2*pi)) * integral(@(w) (2*a_val ./ (a_val^2 + w.^2)).^2, -Inf, Inf);
fprintf('Time Domain Energy: %.6f J\n', E_time);
fprintf('Frequency Domain Energy (Parseval): %.6f J\n', E_freq);
Est. Duration: 6–8 Hours
Request Custom Project →
9. DTFT vs FFT Spectral Leakage & Windowing Analysis
Intermediate
Toolbox: Signal Processing
Deliverables: Code .m, Window Comparison Guide
🎯 Problem & Objective: Discrete-Time Fourier Transform (DTFT) provides continuous frequency representations of discrete sequences, whereas Fast Fourier Transform (FFT) samples the DTFT at discrete frequency bins. This project investigates non-integer cycle truncation, spectral leakage, scalloping loss, and side-lobe suppression using Rectangular, Hann, Hamming, and Blackman-Harris window functions.
⚙️ Key MATLAB Functions:
freqzfftfftshifthannblackmanharriswvtool
📊 Expected Output & Metrics: DTFT continuum vs FFT point-overlay plots, side-lobe attenuation measurements (-13 dB rect vs -92 dB Blackman-Harris), and main-lobe width vs frequency resolution trade-offs.
N = 64; n = 0:N-1;
f_tone = 10.35 / N;
x = sin(2*pi*f_tone*n);
[X_dtft, w] = freqz(x, 1, 1024, 'whole');
X_fft_rect = fft(x);
X_fft_hann = fft(x .* hann(N)');
figure;
plot(w/pi, 20*log10(abs(X_dtft)/max(abs(X_dtft))), 'b-', 'LineWidth', 1.5); hold on;
stem((0:N-1)*(2/N), 20*log10(abs(X_fft_rect)/max(abs(X_fft_rect))), 'ro', 'LineWidth', 1.2);
title('DTFT Continuum vs Sampled FFT Bins (Spectral Leakage)');
xlabel('Normalized Frequency (\times\pi rad/sample)'); ylabel('Magnitude (dB)'); grid on;
Est. Duration: 6–8 Hours
Request Custom Project →
10. Laplace Transform, Region of Convergence (ROC) & Continuous LTI Stability
Intermediate
Toolbox: Symbolic Math & Control System
Deliverables: Code .m, s-Plane Map, ROC Stability Analysis
🎯 Problem & Objective: Evaluate forward and inverse Laplace transforms of continuous differential equations. Map transfer function poles and zeros on the complex $s$-plane ($\sigma + j\omega$), determine the Region of Convergence (ROC) for causal, anti-causal, and non-causal systems, and determine Bounded-Input Bounded-Output (BIBO) stability based on the inclusion of the $j\omega$-axis.
⚙️ Key MATLAB Functions:
laplaceilaplacepzmappolezeroresidue
📊 Expected Output & Metrics: Graphical $s$-plane shaded ROC plots, pole-zero coordinates, partial fraction expansion residues, and time-domain impulse response solutions $h(t)$.
syms t s
H_sym = (2*s + 1) / (s^2 + 5*s + 6);
h_t = ilaplace(H_sym, s, t);
num = [2 1]; den = [1 5 6];
sys = tf(num, den);
sys_poles = pole(sys);
figure;
pzmap(sys); grid on;
title(sprintf('s-Plane: Poles at s = %.1f, %.1f (Causal ROC: Re(s) > -2)', sys_poles(1), sys_poles(2)));
Est. Duration: 6–8 Hours
Request Custom Project →
11. Z-Transform, Pole-Zero Mapping & Discrete LTI Stability Analysis
Intermediate
Toolbox: Symbolic Math & Signal Processing
Deliverables: Code .m, z-Plane Unit Circle Map, Step Response
🎯 Problem & Objective: Solve discrete-time difference equations using bilateral and unilateral Z-transforms. Map poles and zeros onto the complex $z$-plane, compute the discrete ROC, and prove system stability based on unit circle encirclement ($|z| < 1$).
⚙️ Key MATLAB Functions:
ztransiztranszplanerootsresiduezfilter
📊 Expected Output & Metrics: Unit circle pole-zero diagram, discrete impulse response $h[n]$ stems, and stability verification matching Jury's test criteria.
b = [1 0.5];
a = [1 -0.75 0.125];
z_poles = roots(a);
z_zeros = roots(b);
is_stable = all(abs(z_poles) < 1);
fprintf('System Stable: %s (Max Pole Radius: %.4f)\n', mat2str(is_stable), max(abs(z_poles)));
figure; zplane(b, a);
title('Discrete LTI System Pole-Zero Constellation on Unit Circle');
Est. Duration: 6–8 Hours
Request Custom Project →
12. Nyquist-Shannon Sampling Theorem & Anti-Aliasing Filter Design
Beginner
Toolbox: Signal Processing
Deliverables: Code .m, Aliasing Visualizer, Reconstruction Script
🎯 Problem & Objective: Demonstrate the mathematical principle of continuous-to-discrete conversion and Whittaker-Shannon sinc interpolation reconstruction. Simulate critical sampling ($f_s = 2f_{max}$), oversampling ($f_s > 2f_{max}$), and undersampling ($f_s < 2f_{max}$) leading to irreversible spectral foldover aliasing.
⚙️ Key MATLAB Functions:
interp1sincresamplebutterstemfft
📊 Expected Output & Metrics: Overlaid continuous vs discrete sample points, frequency domain alias mirror spectra, and Mean Square Error (MSE) reconstruction curves.
f_analog = 100;
t_cont = 0:0.0001:0.04;
x_cont = sin(2*pi*f_analog*t_cont);
fs_under = 130;
t_under = 0:1/fs_under:0.04;
x_under = sin(2*pi*f_analog*t_under);
fs_over = 500;
t_over = 0:1/fs_over:0.04;
x_over = sin(2*pi*f_analog*t_over);
figure;
plot(t_cont*1000, x_cont, 'k-', 'LineWidth', 1.5); hold on;
stem(t_under*1000, x_under, 'r', 'LineWidth', 1.5);
stem(t_over*1000, x_over, 'b--', 'LineWidth', 1.0);
legend('Analog Signal (100 Hz)', 'Under-Sampled (130 Hz Alias)', 'Over-Sampled (500 Hz)');
xlabel('Time (ms)'); ylabel('Amplitude'); grid on;
Est. Duration: 4–6 Hours
Request Custom Project →
13. LTI System Impulse, Step & Frequency Response Characterization
Beginner
Toolbox: Control System & Signal Processing
Deliverables: Code .m, System Spec Sheet, Transient Plots
🎯 Problem & Objective: Characterize 2nd-order and higher-order Linear Time-Invariant continuous systems. Compute transient specifications: rise time ($t_r$), peak time ($t_p$), percentage overshoot ($%OS$), and settling time ($t_s$) under impulse, step, ramp, and harmonic excitations.
⚙️ Key MATLAB Functions:
tfstepimpulselsimstepinfodamp
📊 Expected Output & Metrics: Overdamped, critically damped, and underdamped step response comparisons, damping ratio ($\zeta$) effects, and settling time metric extraction.
wn = 10;
zetas = [0.2, 0.707, 1.0, 1.5];
figure; hold on;
for z = zetas
sys = tf(wn^2, [1 2*z*wn wn^2]);
step(sys, 2.0);
end
grid on;
legend('\zeta = 0.2 (Underdamped)', '\zeta = 0.707 (Optimal)', '\zeta = 1.0 (Critically)', '\zeta = 1.5 (Overdamped)');
title('2nd-Order LTI Step Response for Various Damping Ratios');
Est. Duration: 4–6 Hours
Request Custom Project →
14. Bode, Nyquist & Nichols Frequency Response Stability Margins
Intermediate
Toolbox: Control System
Deliverables: Code .m, Frequency Response Plots, Stability Report
🎯 Problem & Objective: Analyze open-loop frequency response characteristics to determine closed-loop stability. Construct logarithmic Bode plots, polar Nyquist diagrams (encirclement of the critical $-1 + j0$ point), and Nichols charts to measure Gain Margin (GM), Phase Margin (PM), and delay margin.
⚙️ Key MATLAB Functions:
bodenyquistnicholsmarginallmarginfreqresp
📊 Expected Output & Metrics: Exact gain margin ($dB$) and phase margin (degrees), gain/phase crossover frequencies ($\omega_{gc}, \omega_{pc}$), and Nyquist encirclement count verification.
G = tf(50, conv([1 0], conv([1 2], [1 5])));
[Gm, Pm, Wcg, Wcp] = margin(G);
fprintf('Gain Margin: %.2f dB (at %.2f rad/s)\n', 20*log10(Gm), Wcg);
fprintf('Phase Margin: %.2f deg (at %.2f rad/s)\n', Pm, Wcp);
figure;
subplot(1,2,1); margin(G); grid on;
subplot(1,2,2); nyquist(G); grid on;
Est. Duration: 6–8 Hours
Request Custom Project →
15. State-Space to Transfer Function Conversion & Controllability/Observability
Intermediate
Toolbox: Control System & Symbolic Math
Deliverables: Code .m, Kalman Decomposition Script
🎯 Problem & Objective: Convert continuous dynamic models between State-Space $(\mathbf{A}, \mathbf{B}, \mathbf{C}, \mathbf{D})$ and Transfer Function representations. Evaluate Kalman Controllability Matrix $\mathcal{C} = [\mathbf{B}\;\mathbf{AB}\;\dots\;\mathbf{A}^{n-1}\mathbf{B}]$ and Observability Matrix $\mathcal{O}$ rank conditions to detect unobservable or uncontrollable system modes.
⚙️ Key MATLAB Functions:
ssss2tftf2ssctrbobsvrankcanon
📊 Expected Output & Metrics: State-space matrix transformations, controllability/observability Gramian full-rank verification, and minimal realization pole-zero cancellation.
A = [0 1 0; 0 0 1; -6 -11 -6];
B = [0; 0; 1];
C = [2 1 0];
D = 0;
Co = ctrb(A, B);
Ob = obsv(A, C);
is_ctrb = (rank(Co) == size(A,1));
is_obsv = (rank(Ob) == size(A,1));
[num, den] = ss2tf(A, B, C, D);
sys_tf = tf(num, den);
fprintf('Controllable: %s | Observable: %s\n', mat2str(is_ctrb), mat2str(is_obsv));
disp('Equivalent Transfer Function:'); sys_tf
Est. Duration: 6–8 Hours
Request Custom Project →
16. Analog & Digital Filter Synthesis via Bilinear Transformation
Intermediate
Toolbox: Signal Processing
Deliverables: Code .m, Filter Specs & Frequency Curves
🎯 Problem & Objective: Design prototype continuous analog low-pass filters (Butterworth, Chebyshev Type I/II, and Elliptic) meeting strict attenuation criteria. Map $s$-domain transfer functions to discrete $z$-domain digital filters using the Bilinear Transformation with algebraic frequency pre-warping to prevent non-linear warping distortions.
⚙️ Key MATLAB Functions:
buttordbutterbilinearcheb1ordellipfreqz
📊 Expected Output & Metrics: Analog vs digital frequency response overlay, passband ripple ($\le 1$ dB), stopband attenuation ($\ge 40$ dB), and pole-zero relocation diagrams.
fs = 2000; Wp = 200/(fs/2); Ws = 300/(fs/2); Rp = 1; Rs = 40;
[N, Wn] = buttord(Wp, Ws, Rp, Rs, 's');
[b_analog, a_analog] = butter(N, Wn, 's');
[b_dig, a_dig] = bilinear(b_analog, a_analog, fs);
figure;
[H_dig, f] = freqz(b_dig, a_dig, 1024, fs);
plot(f, 20*log10(abs(H_dig)), 'b', 'LineWidth', 1.5);
grid on; xlabel('Frequency (Hz)'); ylabel('Magnitude (dB)');
title(sprintf('Digital Butterworth Filter Order N = %d via Bilinear Transform', N));
Est. Duration: 6–8 Hours
Request Custom Project →
17. Hilbert Transform, Analytic Signal & Instantaneous Frequency Demodulation
Intermediate
Toolbox: Signal Processing
Deliverables: Code .m, Analytic Envelope Extraction Script
🎯 Problem & Objective: Formulate the analytic complex signal $z(t) = x(t) + j\hat{x}(t)$ by taking the 90-degree phase shift Hilbert transform $\hat{x}(t) = \mathcal{H}\{x(t)\} = \frac{1}{\pi}\int \frac{x(\tau)}{t-\tau}d\tau$. Extract instantaneous amplitude envelope $A(t) = |z(t)|$ and instantaneous frequency $\omega_i(t) = \frac{d\phi(t)}{dt}$ from frequency-modulated radar chirps and mechanical vibration signals.
⚙️ Key MATLAB Functions:
hilbertangleunwrapdiffchirpinstfreq
📊 Expected Output & Metrics: Instantaneous frequency trajectory tracking, single-sideband analytic spectrum (zero negative frequency components), and amplitude envelope tracking accuracy.
fs = 2000; t = 0:1/fs:1;
x = chirp(t, 50, 1, 250);
z = hilbert(x);
inst_amplitude = abs(z);
inst_phase = unwrap(angle(z));
inst_frequency = diff(inst_phase) * (fs / (2*pi));
figure;
subplot(2,1,1); plot(t, x, 'b', t, inst_amplitude, 'r', 'LineWidth', 1.2);
title('Analytic Signal & Instantaneous Envelope A(t)'); legend('Raw Chirp', 'Envelope');
subplot(2,1,2); plot(t(1:end-1), inst_frequency, 'm', 'LineWidth', 1.5);
title('Instantaneous Frequency \omega_i(t)'); xlabel('Time (s)'); ylabel('Freq (Hz)'); grid on;
Est. Duration: 6–8 Hours
Request Custom Project →
18. AM, DSB-SC & SSB Modulation with Synchronous/Envelope Detection
Beginner
Toolbox: Communications & Signal Processing
Deliverables: Code .m, Modulation Spectrogram, Demodulator
🎯 Problem & Objective: Model Amplitude Modulation variants: Standard AM with carrier, Double-Sideband Suppressed-Carrier (DSB-SC), and Single-Sideband (SSB). Evaluate overmodulation distortion ($m > 1$), non-coherent diode envelope detection vs coherent synchronous mixer demodulation under phase error conditions.
⚙️ Key MATLAB Functions:
ammodamdemodssbmodbutterfiltfiltfft
📊 Expected Output & Metrics: Sideband spectrum allocation, modulation index envelope waveforms ($m=0.5, 1.0, 1.5$), power transmission efficiency ($\eta$), and recovered signal SNR.
fs = 20000; t = 0:1/fs:0.02;
fc = 2000; fm = 100;
m_signal = cos(2*pi*fm*t);
s_am = (1 + 0.75*m_signal) .* cos(2*pi*fc*t);
s_dsbsc = m_signal .* cos(2*pi*fc*t);
v_mixed = s_dsbsc .* cos(2*pi*fc*t);
[b,a] = butter(4, (fm*2)/(fs/2), 'low');
m_recovered = 2 * filtfilt(b, a, v_mixed);
figure;
subplot(3,1,1); plot(t*1e3, s_am, 'b'); title('Standard AM Modulated Signal');
subplot(3,1,2); plot(t*1e3, s_dsbsc, 'r'); title('DSB-SC Suppressed Carrier');
subplot(3,1,3); plot(t*1e3, m_recovered, 'g', 'LineWidth', 1.5); title('Recovered Message Signal');
xlabel('Time (ms)');
Est. Duration: 4–6 Hours
Request Custom Project →
19. FM Signal Generation & Phase-Locked Loop (PLL) Demodulator
Intermediate
Toolbox: Communications & Signal Processing
Deliverables: Code .m, Simulink PLL Model, THD Report
🎯 Problem & Objective: Simulate wideband Frequency Modulation (FM) using Carson's bandwidth rule $B = 2(\Delta f + f_m)$. Construct a discrete Phase-Locked Loop (PLL) receiver comprising a Phase Detector multiplier, Loop Filter integrator, and Voltage-Controlled Oscillator (VCO) to lock carrier phase and demodulate audio without distortion.
⚙️ Key MATLAB Functions:
fmmodfmdemodcumsumatan2besseljfilter
📊 Expected Output & Metrics: Bessel function spectral sideband distribution ($J_n(\beta)$), PLL transient lock time (<2 ms), tracking error phase margin, and demodulated audio SNR.
fs = 200000; t = 0:1/fs:0.01;
fc = 20000; fm = 500; freqdev = 5000;
m_t = sin(2*pi*fm*t);
phi_t = 2*pi*fc*t + 2*pi*freqdev*cumsum(m_t)/fs;
s_fm = cos(phi_t);
m_demod = fmdemod(s_fm, fc, fs, freqdev);
figure;
subplot(2,1,1); plot(t*1e3, s_fm, 'b'); title('Frequency Modulated Waveform'); xlim([0 2]);
subplot(2,1,2); plot(t*1e3, m_demod, 'r', 'LineWidth', 1.5); title('PLL Demodulated Message Signal');
xlabel('Time (ms)');
Est. Duration: 1–2 Weeks
Request Custom Project →
20. Cross-Correlation & Matched Filter for Radar Time-Delay Estimation
Intermediate
Toolbox: Radar & Signal Processing
Deliverables: Code .m, Target Range Estimator, SNR Analysis
🎯 Problem & Objective: Implement the optimal Linear Time-Invariant Matched Filter $h(t) = s^*(T - t)$ that maximizes output Signal-to-Noise Ratio (SNR) in the presence of additive white Gaussian noise (AWGN). Cross-correlate received echo reflections with transmitted linear frequency modulated (LFM) chirps to accurately estimate round-trip time delay ($\tau = 2R/c$) and target distance.
⚙️ Key MATLAB Functions:
xcorrchirpfindpeaksawgnphased.MatchedFilter
📊 Expected Output & Metrics: Matched filter compressed pulse peak, range resolution improvement ($c/(2B)$), SNR processing gain (+18 dB), and target distance estimation accuracy (<0.5% error).
c = 3e8; fs = 20e6; T_pulse = 10e-6;
t_pulse = 0:1/fs:T_pulse;
tx_pulse = chirp(t_pulse, 0, T_pulse, 5e6);
target_delay = 2 * 1500 / c;
delay_samples = round(target_delay * fs);
rx_echo = [zeros(1, delay_samples), 0.1*tx_pulse, zeros(1, 200)];
rx_noisy = awgn(rx_echo, -5, 'measured');
[corr_out, lags] = xcorr(rx_noisy, tx_pulse);
time_axis = (lags / fs) * c / 2;
[~, max_idx] = max(corr_out);
est_range = time_axis(max_idx);
fprintf('Target Actual: 1500.0 m | Estimated Range: %.2f m\n', est_range);
Est. Duration: 1–2 Weeks
Request Custom Project →
21. LTI System Identification & Transfer Function Estimation
Advanced
Toolbox: System Identification & Control
Deliverables: Code .m, IDdata Workspace, Validation Curves
🎯 Problem & Objective: Estimate unknown black-box Linear Time-Invariant dynamical transfer functions from measured input-output data corrupted by plant noise. Excite the system with Pseudo-Random Binary Sequences (PRBS), estimate ARX and continuous transfer function models using non-linear least squares, and validate model fits against independent test datasets.
⚙️ Key MATLAB Functions:
iddatatfestarxcompareidprbsresid
📊 Expected Output & Metrics: Normalized Root Mean Square Error (NRMSE) fit percentage (>92%), residual autocorrelation confidence intervals, and pole-zero uncertainty ellipses.
Ts = 0.05; t = (0:Ts:30)';
G_true = tf(25, [1 3 25]);
u = idinput(length(t), 'PRBS', [0 0.2]);
y_clean = lsim(G_true, u, t);
y_noisy = y_clean + 0.15*randn(size(y_clean));
data = iddata(y_noisy, u, Ts);
np = 2; nz = 0;
sys_est = tfest(data, np, nz);
figure; compare(data, sys_est); grid on;
title('System Identification: Measured vs Estimated LTI Response');
Est. Duration: 2–3 Weeks
Request Custom Project →
22. Fixed-Point Quantization & Word-Length Effects in Digital LTI Systems
Advanced
Toolbox: Fixed-Point Designer & DSP System
Deliverables: Code .m, Fixed-Point Scaling Model, SQNR Report
🎯 Problem & Objective: Infinite-precision double floating-point models often diverge when implemented on resource-constrained embedded microcontrollers (DSP/FPGA). This project analyzes coefficient quantization errors, accumulator register overflow, zero-input limit cycle oscillations, and Signal-to-Quantization-Noise Ratio (SQNR) across 8-bit, 16-bit (Q15), and 32-bit fixed-point word architectures.
⚙️ Key MATLAB Functions:
finumerictypefimathqformatfiltersnr
📊 Expected Output & Metrics: Floating vs fixed-point frequency response deviation curves, SQNR measurements ($\approx 6.02B + 1.76$ dB rule), and coefficient pole sensitivity maps.
[b, a] = butter(2, 0.25);
x = randn(1, 1000);
y_double = filter(b, a, x);
T = numerictype(1, 16, 15);
F = fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Saturate');
b_fi = fi(b, T); a_fi = fi(a, T);
x_fi = fi(x, T);
y_fi = filter(b_fi, a_fi, x_fi);
sqnr_val = snr(y_double, double(y_fi) - y_double);
fprintf('16-bit Q15 Fixed-Point SQNR: %.2f dB\n', sqnr_val);
Est. Duration: 2–3 Weeks
Request Custom Project →