1. Energy-Efficient LEACH Routing Protocol for Wireless Sensor Networks (WSN)
Intermediate
Toolbox: Communications, Graph Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Implement the Low-Energy Adaptive Clustering Hierarchy (LEACH) protocol in MATLAB where 100 randomly distributed sensor nodes elect Cluster Heads (CHs) based on a probabilistic threshold equation $T(n) = \frac{p}{1 - p \cdot (r \bmod \frac{1}{p})}$. Minimize battery depletion and extend network lifetime across 1000 simulation rounds.
βοΈ Key MATLAB Functions:
randpdist2minscatterplot
π Expected Output & Metrics: Number of alive nodes vs round index, First Node Dead (FND) and Half Nodes Dead (HND) metrics, total remaining network energy (Joules), and throughput (packets delivered to base station).
N = 100; xm = 100; ym = 100; sink = [50, 50];
p = 0.05; E0 = 0.5; Eelec = 50e-9; Efs = 10e-12; Emp = 0.0013e-12;
d0 = sqrt(Efs / Emp); packet_len = 4000;
nodes_x = rand(1, N) * xm; nodes_y = rand(1, N) * ym;
energy = ones(1, N) * E0; alive_nodes = zeros(1, 1000);
for r = 1:1000
alive = find(energy > 0);
alive_nodes(r) = length(alive);
if isempty(alive), break; end
Tn = p / (1 - p * mod(r, round(1/p)));
ch_candidates = alive(rand(1, length(alive)) < Tn);
if isempty(ch_candidates), ch_candidates = alive(randi(length(alive))); end
for i = 1:length(alive)
node_idx = alive(i);
dists = sqrt((nodes_x(node_idx) - nodes_x(ch_candidates)).^2 + ...
(nodes_y(node_idx) - nodes_y(ch_candidates)).^2);
d = min(dists);
if d < d0
E_tx = Eelec * packet_len + Efs * packet_len * (d^2);
else
E_tx = Eelec * packet_len + Emp * packet_len * (d^4);
end
energy(node_idx) = energy(node_idx) - E_tx;
end
end
plot(1:1000, alive_nodes, 'LineWidth', 2, 'Color', '#0056b3');
grid on; xlabel('Simulation Rounds'); ylabel('Alive Nodes Count');
title('LEACH Protocol Network Lifetime Simulation');
2. AODV vs DSR Reactive Routing Protocol Simulation in Mobile Ad-Hoc Networks (MANET)
Intermediate
Toolbox: Communications, Graph Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Model dynamic node mobility using the Random Waypoint (RWP) model in a 500m x 500m area. Compare Ad-hoc On-Demand Distance Vector (AODV) routing against Dynamic Source Routing (DSR) in terms of Route Request (RREQ) broadcast storm overhead and link breakage recovery times.
βοΈ Key MATLAB Functions:
graphshortestpathpdist2adjacencytic
π Expected Output & Metrics: Packet Delivery Ratio (PDR %) vs Node Speed (5β30 m/s), average end-to-end latency (ms), routing control overhead, and route cache hit ratios.
numNodes = 40; txRange = 80; area = 500;
pos = rand(numNodes, 2) * area;
velocities = (rand(numNodes, 2) - 0.5) * 15;
distMat = pdist2(pos, pos);
adjMat = distMat <= txRange & distMat > 0;
G = graph(adjMat);
[path_nodes, path_len] = shortestpath(G, 1, numNodes);
figure; p = plot(G, 'XData', pos(:,1), 'YData', pos(:,2), 'NodeColor', '#3b82f6');
if ~isempty(path_nodes)
highlight(p, path_nodes, 'EdgeColor', '#10b981', 'LineWidth', 2.5);
title(['AODV Discovered Active Route: Hop Count = ', num2str(path_len)]);
else
title('Route Discovery Failed: Destination Partitioned');
end
3. Dijkstra and Bellman-Ford Shortest Path Algorithm for Dynamic IP Routing
Beginner
Toolbox: Graph Theory & Optimization
Deliverables: Code .m, Report
π― Problem & Objective: Implement Link-State (OSPF-style Dijkstra) and Distance-Vector (RIP-style Bellman-Ford) routing algorithms on arbitrary mesh topologies with link cost fluctuations and dynamic link failure rerouting.
βοΈ Key MATLAB Functions:
graphshortestpathdistanceshighlightrmedge
π Expected Output & Metrics: Routing convergence time (ms), routing table generation, total path cost under normal and link-failed conditions, and visual sub-millisecond path rerouting.
s = [1 1 2 2 3 4 4 5 6];
t = [2 3 3 4 5 5 6 7 7];
weights = [4 2 1 5 8 2 6 3 1];
G = graph(s, t, weights);
[path1, cost1] = shortestpath(G, 1, 7);
G_failed = rmedge(G, 4, 5);
[path2, cost2] = shortestpath(G_failed, 1, 7);
fprintf('Primary Path: %s (Cost: %d)\n', num2str(path1), cost1);
fprintf('Failover Re-routed Path: %s (Cost: %d)\n', num2str(path2), cost2);
4. Contributions to Edge Computing: Task Offloading and Resource Allocation in Massive IoT
Advanced
Toolbox: Optimization, Communications
Deliverables: Code .m, Report
π― Problem & Objective: Preserving original research topic: As over 50 billion connected IoT and Cyber-Physical System (CPS) devices generate trillions of gigabytes of data, remote cloud computing suffers intolerable backhaul latency. Formulate an optimal edge computing offloading framework in MATLAB that minimizes total task completion delay and mobile terminal energy consumption subject to stringent Quality of Service (QoS) constraints.
βοΈ Key MATLAB Functions:
fminconlinproggaboxplotsum
π Expected Output & Metrics: Task processing latency reduction (vs purely local execution and purely cloud offloading), energy consumption Pareto frontier, CPU clock frequency allocation across multi-access edge servers (MEC), and QoS violation percentage.
numDevices = 20; taskData = randi([500, 2000], 1, numDevices) * 1e3;
cpuCycles = taskData * 1000;
f_local = 1e9; f_edge = 10e9; B = 20e6; P_tx = 0.2;
snr = rand(1, numDevices) * 20 + 5;
rate = B * log2(1 + 10.^(snr/10));
T_local = cpuCycles / f_local;
T_edge = (taskData ./ rate) + (cpuCycles / f_edge);
offload_decision = T_edge < T_local;
latency_saved = sum(T_local) - sum(T_edge(offload_decision) + T_local(~offload_decision));
fprintf('Total Latency Saved by Edge Offloading: %.2f seconds (%.1f%%)\n', ...
latency_saved, (latency_saved / sum(T_local))*100);
5. Design of Wideband Antenna for Wireless Network-On-Chip (WiNoC) in Multimedia Systems
Intermediate
Toolbox: Antenna Toolbox, RF Toolbox
Deliverables: Code .m, Report
π― Problem & Objective: Preserving original research topic: Multi-core processors with Gb/s multimedia traffic encounter metallic interconnect bottlenecks. Design and simulate a mm-wave bow-tie antenna on conventional silicon CMOS top-metal layers for Wireless Network-on-Chip (WiNoC) inter-core communications in MATLAB.
βοΈ Key MATLAB Functions:
antenna.Bowtiesparametersrfplotpatternimpedance
π Expected Output & Metrics: $S_{11}$ reflection coefficient (< -10 dB bandwidth at 60 GHz), radiation efficiency, 3D radiation gain pattern, and comparison against standard on-chip zig-zag antennas.
fc = 60e9;
ant = design(antenna.BowtieRounded, fc);
ant.Length = 1.2e-3; ant.Width = 0.8e-3;
freqRange = linspace(50e9, 70e9, 50);
s = sparameters(ant, freqRange);
figure; rfplot(s); grid on;
title('WiNoC On-Chip Bow-Tie Antenna S11 Return Loss (dB)');
figure; pattern(ant, fc);
6. MATLAB-Based Testbed for Integration, Evaluation and Comparison of Heterogeneous Stereo Vision Matching over Distributed Networks
Advanced
Toolbox: Computer Vision, Image Processing, Parallel Computing
Deliverables: Code .m, Report
π― Problem & Objective: Preserving original research topic: Build a standardized modular MATLAB testbed that chains and benchmarks heterogeneous stereo matching algorithms (Block Matching, Semi-Global Matching, Graph Cuts) across distributed network nodes, evaluating algorithm execution time, disparity accuracy, and network payload transmission overhead.
βοΈ Key MATLAB Functions:
disparityBMdisparitySGMrectifyStereoImagesimshowpairimmse
π Expected Output & Metrics: Disparity map mean square error (MSE), execution latency per image frame (ms), bandwidth compression ratio, and comparative algorithmic ranking.
I1 = rgb2gray(imread('scene_left.png'));
I2 = rgb2gray(imread('scene_right.png'));
tic; dispBM = disparityBM(I1, I2, 'DisparityRange', [0 64]); t_BM = toc;
tic; dispSGM = disparitySGM(I1, I2, 'DisparityRange', [0 64]); t_SGM = toc;
fprintf('BM Processing Time: %.3f s | SGM Processing Time: %.3f s\n', t_BM, t_SGM);
figure; subplot(1,2,1); imshow(dispBM, [0 64]); title('Disparity Map (BM)');
subplot(1,2,2); imshow(dispSGM, [0 64]); title('Disparity Map (SGM)');
7. Design and Evaluation of Discrete Wavelet Transform (DWT) Multi-Signal Receiver for Network Interference Mitigation
Intermediate
Toolbox: Wavelet Toolbox, Signal Processing
Deliverables: Code .m, Report
π― Problem & Objective: Preserving original research topic: Wideband wireless network receivers must process weak secondary signals in the presence of strong interference and spurious frequencies. Implement multi-resolution DWT decomposition in MATLAB to filter out high-frequency spurs and reconstruct weak network signals without degrading latency.
βοΈ Key MATLAB Functions:
wavedecwaverecwdenoisedwtspectrogram
π Expected Output & Metrics: Output Signal-to-Interference-plus-Noise Ratio (SINR gain in dB), spur attenuation (dB), Bit Error Rate (BER), and spectral waterfall representations.
Fs = 1e6; t = 0:1/Fs:0.005;
sig1 = sin(2*pi*50e3*t);
sig2 = 0.2 * sin(2*pi*120e3*t);
spur = 0.8 * sin(2*pi*350e3*t);
rx_composite = sig1 + sig2 + spur + 0.1*randn(size(t));
[c, l] = wavedec(rx_composite, 4, 'db4');
c_denoised = wthrmngr('den', 'sqtwolog', c, l);
clean_sig = waverec(c_denoised, l, 'db4');
figure; plot(t(1:500)*1e3, rx_composite(1:500), 'r', t(1:500)*1e3, clean_sig(1:500), 'b');
xlabel('Time (ms)'); ylabel('Amplitude'); legend('Received Interference', 'DWT Cleaned');
8. IoT-Based Real-Time Gas Monitoring and RSSI Weighted Centroid Miner Localization for Underground Coal Mines
Advanced
Toolbox: Statistics & Machine Learning, Optimization
Deliverables: Code .m, Report
π― Problem & Objective: Preserving original research topic: Develop an underground mine safety IoT testbed in MATLAB integrating multi-gas telemetry (CH4, CO, CO2, temperature) with cluster-based outlier detection (>90% anomaly accuracy) and RSSI-based weighted centroid localization for tracking miners inside hazardous tunnels.
βοΈ Key MATLAB Functions:
kmeansfitlmpdist2scattercorrcoef
π Expected Output & Metrics: Miner localization mean error (< 1.5 m), sensor regression correlation ($R^2 > 0.97$), hazardous gas event trigger response time (ms), and spatial safety alert maps.
anchors = [0, 0; 50, 0; 100, 0; 150, 0; 200, 0];
true_miner_pos = [125, 4];
P0 = -40; n = 2.8;
d_true = sqrt(sum((anchors - true_miner_pos).^2, 2));
rssi = P0 - 10 * n * log10(d_true) + randn(size(d_true))*1.5;
weights = (10.^(rssi / 20)).^2;
est_miner_pos = sum(anchors .* weights, 1) / sum(weights);
loc_error = norm(true_miner_pos - est_miner_pos);
fprintf('Estimated Miner Position: [%.1f, %.1f] | Error: %.2f meters\n', ...
est_miner_pos(1), est_miner_pos(2), loc_error);
9. Software-Defined Networking (SDN) Controller with OpenFlow Dynamic Flow Routing
Advanced
Toolbox: Graph Theory & Network Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Implement an OpenFlow-inspired centralized Software-Defined Networking (SDN) controller script that decouples control plane intelligence from data plane switches. Dynamically push flow table updates based on real-time link congestions and QoS priority queues.
βοΈ Key MATLAB Functions:
digraphshortestpathtreebfsearchplotaddedge
π Expected Output & Metrics: Flow setup delay (ms), throughput improvement through adaptive multipath load balancing, flow table modification overhead, and zero packet drop under link failure.
s = [1 1 2 2 3 4]; t = [2 3 4 5 5 5];
capacity = [100 100 50 50 100 100];
utilization = [90 20 40 10 15 30];
dynamic_cost = 1 ./ (capacity - utilization + 1e-3);
G = digraph(s, t, dynamic_cost);
optimal_path = shortestpath(G, 1, 5);
fprintf('SDN Controller Flow Table Installation for Flow 1->5: %s\n', num2str(optimal_path));
10. DDoS Attack Detection and Network Intrusion Prevention Using Machine Learning
Intermediate
Toolbox: Statistics & Machine Learning
Deliverables: Code .m, Report
π― Problem & Objective: Simulate volumetric DDoS attack traffic (TCP SYN floods, UDP floods, and HTTP floods) combined with legitimate traffic. Train an SVM / Random Forest classifier in MATLAB using flow entropy, packet inter-arrival times, and byte rates to detect intrusions with high accuracy.
βοΈ Key MATLAB Functions:
fitcsvmpredictconfusionchartcrossvalroc
π Expected Output & Metrics: Detection Accuracy (>98%), False Positive Rate (<1%), Confusion Matrix, Receiver Operating Characteristic (ROC) curve, and classification latency.
N_samples = 1000;
normal_traffic = [randn(N_samples/2,1)*20 + 50, randn(N_samples/2,1)*100 + 400, ...
randn(N_samples/2,1)*10 + 35, rand(N_samples/2,1)*0.1];
ddos_traffic = [randn(N_samples/2,1)*100 + 800, randn(N_samples/2,1)*300 + 1500, ...
randn(N_samples/2,1)*2 + 3, rand(N_samples/2,1)*0.4 + 0.6];
X = [normal_traffic; ddos_traffic];
Y = [zeros(N_samples/2, 1); ones(N_samples/2, 1)];
svmModel = fitcsvm(X, Y, 'KernelFunction', 'rbf', 'Standardize', true);
cvModel = crossval(svmModel);
loss = kfoldLoss(cvModel);
fprintf('DDoS Classifier 10-Fold Accuracy: %.2f%%\n', (1 - loss)*100);
11. CSMA/CA vs ALOHA MAC Layer Protocol Throughput and Collision Modeling
Beginner
Toolbox: Communications, Statistics
Deliverables: Code .m, Report
π― Problem & Objective: Develop discrete-event simulation models for Pure ALOHA, Slotted ALOHA, and IEEE 802.11 CSMA/CA with binary exponential backoff. Demonstrate theoretical vs simulated channel throughput $S$ as a function of network offered load $G$.
βοΈ Key MATLAB Functions:
randcumsumfindhistcountsplot
π Expected Output & Metrics: Throughput curves highlighting peak capacity ($18.4\%$ for Pure ALOHA, $36.8\%$ for Slotted ALOHA, $>75\%$ for CSMA/CA), collision probability, and packet backoff delay.
G = linspace(0.01, 3, 100);
S_pure_aloha = G .* exp(-2 * G);
S_slotted_aloha = G .* exp(-G);
S_csma = (G .* exp(-0.1*G)) ./ (G + 1 - exp(-G));
figure;
plot(G, S_pure_aloha, 'r--', 'LineWidth', 2); hold on;
plot(G, S_slotted_aloha, 'b-.', 'LineWidth', 2);
plot(G, S_csma, 'g-', 'LineWidth', 2);
grid on; xlabel('Offered Traffic Load (G)'); ylabel('Channel Throughput (S)');
legend('Pure ALOHA (18.4% max)', 'Slotted ALOHA (36.8% max)', 'CSMA/CA');
title('MAC Protocol Channel Capacity Comparison');
12. Vehicular Ad-Hoc Network (VANET) V2V/V2I Safety Message Dissemination with Doppler Fading
Advanced
Toolbox: Communications, Wireless Network Testbench
Deliverables: Code .m, Report
π― Problem & Objective: Simulate highway vehicle-to-vehicle (V2V) and vehicle-to-infrastructure (V2I) safety message broadcasting under IEEE 802.11p (DSRC) and C-V2X. Incorporate high-speed Doppler spread and road-side unit (RSU) multi-hop relaying.
βοΈ Key MATLAB Functions:
comm.RayleighChannelpdist2quiverscatterplot
π Expected Output & Metrics: Cooperative Awareness Message (CAM) delivery ratio (>99% within 100ms emergency deadline), Doppler frequency shift impact (Hz), and RSU caching coverage.
numVehicles = 30; roadLength = 1000;
veh_x = sort(rand(1, numVehicles) * roadLength);
veh_speed = randi([80, 130], 1, numVehicles);
fc = 5.9e9; c = 3e8;
fd = (veh_speed / 3.6) * (fc / c);
source = 5; txRange = 250;
rx_dist = abs(veh_x - veh_x(source));
rx_pdr = exp(-rx_dist / (txRange/2));
figure; stem(veh_x, rx_pdr, 'filled', 'Color', '#0056b3');
grid on; xlabel('Highway Position (m)'); ylabel('Packet Delivery Ratio (PDR)');
title('VANET V2V Emergency Message Broadcast Reception');
13. Token Bucket and Leaky Bucket Traffic Shaping and Congestion Control in TCP/IP
Beginner
Toolbox: Communications, Signal Processing
Deliverables: Code .m, Report
π― Problem & Objective: Implement traffic policing and shaping algorithms (Token Bucket and Leaky Bucket) to regulate bursty network traffic inflows, smooth peak packet rates, and prevent buffer overflow at bottleneck routers.
βοΈ Key MATLAB Functions:
stairscumsumdiffzerosplot
π Expected Output & Metrics: Conformance rate (%), maximum buffer queue depth, packet drop rate under burst conditions, and comparative delay-jitter analysis.
bucket_capacity = 20; token_rate = 5;
time_steps = 50; incoming_packets = poissrnd(8, 1, time_steps);
transmitted = zeros(1, time_steps); tokens = bucket_capacity;
for t = 1:time_steps
tokens = min(bucket_capacity, tokens + token_rate);
allow = min(tokens, incoming_packets(t));
transmitted(t) = allow;
tokens = tokens - allow;
end
figure; stairs(incoming_packets, 'r--', 'LineWidth', 1.5); hold on;
stairs(transmitted, 'b-', 'LineWidth', 2); grid on;
xlabel('Time Slot (s)'); ylabel('Packet Count'); legend('Bursty Inflow', 'Shaped Outflow');
title('Token Bucket Traffic Shaping Simulation');
14. LoRaWAN Gateway Placement and Spreading Factor (SF) Optimization for Smart Cities
Intermediate
Toolbox: Optimization, Wireless Communications
Deliverables: Code .m, Report
π― Problem & Objective: Model long-range wide-area network (LoRaWAN) coverage across a 10 km smart city radius. Assign optimal Spreading Factors (SF7 to SF12) and gateway locations to mitigate co-spreading-factor collisions and path loss.
βοΈ Key MATLAB Functions:
pdist2contourfscatterlegendlog10
π Expected Output & Metrics: Packet Reception Rate (PRR %), energy consumed per successfully acknowledged packet, and 2D spatial SNR heatmaps.
numNodes = 200; radius = 5000;
r = sqrt(rand(1, numNodes)) * radius;
theta = rand(1, numNodes) * 2 * pi;
nodes = [r.*cos(theta); r.*sin(theta)]';
d = sqrt(sum(nodes.^2, 2)) / 1000;
PL = 120 + 37.6 * log10(d);
RSSI = 14 - PL;
SF = zeros(numNodes, 1);
SF(RSSI >= -123) = 7; SF(RSSI < -123 & RSSI >= -126) = 8;
SF(RSSI < -126 & RSSI >= -129) = 9; SF(RSSI < -129 & RSSI >= -132) = 10;
SF(RSSI < -132 & RSSI >= -134.5) = 11; SF(RSSI < -134.5) = 12;
figure; scatter(nodes(:,1), nodes(:,2), 30, SF, 'filled'); colorbar;
title('LoRaWAN Spreading Factor (SF7-SF12) City Distribution');
15. Energy-Harvesting Wireless Sensor Network (EH-WSN) with Adaptive Sleep Scheduling
Intermediate
Toolbox: Optimization, Simulink
Deliverables: Code .m, Report
π― Problem & Objective: Model solar and RF energy harvesting transceivers with supercapacitor storage dynamics. Implement an adaptive duty-cycle algorithm that dynamically tunes sensor active/sleep intervals to achieve energy-neutral operation.
βοΈ Key MATLAB Functions:
ode45cumsumtrapzplotmin
π Expected Output & Metrics: Supercapacitor state-of-charge (SoC %) over 24-hour diurnal cycle, energy neutral violation rate (0%), and dynamic packet throughput adaptation.
hours = 0:0.1:24;
harvest_power = max(0, 15 * sin(pi * (hours - 6) / 12));
battery_cap = 500;
soc = zeros(size(hours)); soc(1) = 250;
for i = 2:length(hours)
dt = 0.1 * 3600;
duty_cycle = min(1.0, max(0.05, soc(i-1) / battery_cap));
p_consumed = duty_cycle * 10;
delta_E = (harvest_power(i) - p_consumed) * (0.1 * 3.6);
soc(i) = min(battery_cap, max(0, soc(i-1) + delta_E));
end
figure; plot(hours, soc, 'LineWidth', 2, 'Color', '#10b981');
grid on; xlabel('Time (Hours)'); ylabel('Supercapacitor Energy (mJ)');
title('Energy-Neutral EH-WSN Adaptive Scheduling');
16. Multi-Hop Wireless Mesh Network Throughput and SINR Interference Modeling
Intermediate
Toolbox: Communications, Graph Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Build a multi-hop wireless mesh topology. Compute the Signal-to-Interference-plus-Noise Ratio (SINR) matrices and Shannon link capacities to quantify throughput degradation and bottleneck link saturation across forwarding hops.
βοΈ Key MATLAB Functions:
graphdistanceslog2pdist2imagesc
π Expected Output & Metrics: Multi-hop end-to-end capacity (Mbps), interference conflict graph, Jain's fairness index, and bottleneck throughput heatmap.
node_pos = [0 0; 50 0; 100 0; 150 0; 200 0; 250 0];
P_tx = 0.1; N0 = 1e-10; alpha = 3.5; B = 20e6;
d_desired = 50;
P_signal = P_tx * (d_desired.^-alpha);
P_interf = P_tx * (100^-alpha);
SINR = P_signal / (P_interf + N0);
capacity_hop = B * log2(1 + SINR) / 1e6;
fprintf('Per-Hop Bottleneck Shannon Capacity: %.2f Mbps (SINR: %.2f dB)\n', ...
capacity_hop, 10*log10(SINR));
17. RPL (Routing Protocol for Low-Power and Lossy Networks) Simulation in 6LoWPAN IoT
Advanced
Toolbox: Communications, Graph Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Implement the IPv6 RPL standard (RFC 6550) in MATLAB for constrained IoT networks. Construct Destination-Oriented Directed Acyclic Graphs (DODAG) using Minimum Rank with Hysteresis Objective Function (MRHOF) based on Expected Transmission Count (ETX).
βοΈ Key MATLAB Functions:
digraphshortestpathpdist2plottext
π Expected Output & Metrics: DODAG DAG rank convergence, DIO/DIS control message overhead, packet delivery ratio under channel packet loss, and parent switching stability.
N = 20; root = 1; pos = rand(N, 2) * 100; pos(1,:) = [50, 90];
etx_matrix = pdist2(pos, pos) / 25 + rand(N, N)*0.5;
G = graph(etx_matrix < 4 & etx_matrix > 0);
dists = distances(G, root);
[~, parents] = min(etx_matrix + dists, [], 2);
figure; p = plot(G, 'XData', pos(:,1), 'YData', pos(:,2), 'NodeColor', '#0056b3');
title('RPL DODAG Tree Formation for 6LoWPAN Networks');
18. Network Topology Generator and Graph Theory Metrics Analyzer (Degree, Betweenness, Centrality)
Beginner
Toolbox: Graph Theory & Network Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Generate synthetic topologies (ErdΕsβRΓ©nyi random, BarabΓ‘siβAlbert scale-free, Small-World Watts-Strogatz). Compute betweenness centrality, degree distribution, and network resilience against targeted hub removal attacks.
βοΈ Key MATLAB Functions:
graphcentralitydistancesconncompplot
π Expected Output & Metrics: Degree distribution power-law fit, node betweenness scores, average path length, and percolation threshold under random vs targeted node deletions.
N = 50; p_edge = 0.12;
adj = rand(N) < p_edge; adj = triu(adj, 1); adj = adj + adj';
G = graph(adj);
bc = centrality(G, 'betweenness');
figure; p = plot(G, 'NodeCData', bc, 'MarkerSize', 4 + 10*(bc/max(bc)));
colorbar; colormap('jet'); title('Network Node Betweenness Centrality Heatmap');
19. TCP Congestion Control Comparison: Reno, CUBIC, Vegas, and BBR Simulation
Intermediate
Toolbox: Communications, Control System
Deliverables: Code .m, Report
π― Problem & Objective: Simulate TCP congestion window (`cwnd`) dynamics under high Bandwidth-Delay Product (BDP) links. Compare loss-based algorithms (TCP Reno, CUBIC) with delay-based (Vegas) and model-based (Google BBR) in terms of throughput, bufferbloat, and RTT fairness.
βοΈ Key MATLAB Functions:
zerosstairsplotmeanlegend
π Expected Output & Metrics: `cwnd` progression curves over 200 RTT intervals, bottleneck router queue occupancy, packet retransmission rate, and fairness index.
rtt_steps = 100;
cwnd_reno = zeros(1, rtt_steps); cwnd_reno(1) = 1;
cwnd_cubic = zeros(1, rtt_steps); cwnd_cubic(1) = 1;
ssthresh = 32; C = 0.4; beta = 0.2; W_max = 40;
for t = 2:rtt_steps
if mod(t, 25) == 0
cwnd_reno(t) = cwnd_reno(t-1) / 2;
else
cwnd_reno(t) = cwnd_reno(t-1) + 1;
end
if mod(t, 25) == 0
cwnd_cubic(t) = cwnd_cubic(t-1) * (1 - beta);
else
K = (W_max * beta / C)^(1/3);
t_epoch = mod(t, 25);
cwnd_cubic(t) = C * (t_epoch - K)^3 + W_max;
end
end
figure; plot(cwnd_reno, 'r--', 'LineWidth', 2); hold on;
plot(cwnd_cubic, 'b-', 'LineWidth', 2); grid on;
xlabel('RTT Round'); ylabel('Congestion Window (cwnd)');
legend('TCP Reno', 'TCP CUBIC'); title('TCP Congestion Control Dynamics');
20. Cross-Layer Optimization of Routing and MAC Layer in Cognitive Radio Ad-Hoc Networks (CRAHNs)
Advanced
Toolbox: Optimization, Communications
Deliverables: Code .m, Report
π― Problem & Objective: Formulate joint dynamic spectrum access (DSA), transmit power allocation, and multi-hop route selection in Cognitive Radio Networks. Maximize secondary user throughput without causing harmful interference to primary licensed users.
βοΈ Key MATLAB Functions:
fminconcomm.RayleighChannelgraphpdist2plot
π Expected Output & Metrics: Secondary network sum-rate (Mbps), Primary User collision probability (<0.01), spectrum handoff latency, and cross-layer routing overhead.
M = 5;
pu_activity = rand(1, M) < 0.4;
available_channels = find(~pu_activity);
fprintf('Detected %d Free Channels for Cognitive Transmission: %s\n', ...
length(available_channels), num2str(available_channels));
21. Quality of Service (QoS) Queuing Models (M/M/1, M/M/c/K, Priority Queue) Performance Evaluation
Beginner
Toolbox: Statistics & Machine Learning
Deliverables: Code .m, Report
π― Problem & Objective: Implement discrete-event simulations for M/M/1, M/M/c/K, and Strict Priority packet queues in MATLAB. Empirically validate Little's Law ($L = \lambda W$) and evaluate router buffer packet drop probabilities under varying utilization $\rho$.
βοΈ Key MATLAB Functions:
exprndcumsumhistcountsplotmean
π Expected Output & Metrics: Average waiting time $W_q$ (ms), buffer blocking probability $P_B$ vs buffer capacity $K$, and server utilization comparison.
lambda = 8; mu = 10; N_packets = 10000;
inter_arr = exprnd(1/lambda, 1, N_packets);
serv_time = exprnd(1/mu, 1, N_packets);
arr_times = cumsum(inter_arr);
depart_times = zeros(1, N_packets);
depart_times(1) = arr_times(1) + serv_time(1);
for i = 2:N_packets
depart_times(i) = max(arr_times(i), depart_times(i-1)) + serv_time(i);
end
wait_times = depart_times - arr_times;
fprintf('Simulated Mean System Time W: %.4f s | Theoretical W: %.4f s\n', ...
mean(wait_times), 1 / (mu - lambda));
22. Blockchain-Enabled Decentralized Consensus and Secure Routing in IoT Networks
Advanced
Toolbox: Statistics, Communications
Deliverables: Code .m, Report
π― Problem & Objective: Implement a lightweight blockchain ledger with Proof-of-Authority (PoA) consensus in MATLAB. Secure IoT multi-hop routing by maintaining distributed immutable node reputation scores and isolating blackhole and sybil attacker nodes.
βοΈ Key MATLAB Functions:
structpdist2tableplotfind
π Expected Output & Metrics: Malicious node isolation rate (>99%), blockchain ledger transaction commit latency (ms), packet forwarding reliability, and storage overhead.
N = 10; reputation = ones(1, N) * 1.0;
malicious_node = 4;
for round = 1:50
forwarded = rand(1, N) > 0.05;
forwarded(malicious_node) = rand() < 0.2;
reputation(forwarded) = min(1.0, reputation(forwarded) + 0.02);
reputation(~forwarded) = max(0.0, reputation(~forwarded) - 0.15);
end
trusted_route_nodes = find(reputation > 0.5);
fprintf('Malicious Node 4 Trust Score: %.2f | Isolated: %s\n', ...
reputation(malicious_node), mat2str(~ismember(malicious_node, trusted_route_nodes)));
23. ZigBee (IEEE 802.15.4) Cluster-Tree Topology and Packet Delivery Ratio (PDR) Simulation
Intermediate
Toolbox: Communications, Wireless Network Testbench
Deliverables: Code .m, Report
π― Problem & Objective: Model an IEEE 802.15.4 ZigBee Personal Area Network (PAN) consisting of a Coordinator, Full-Function Routers, and Reduced-Function End Devices. Analyze beacon-enabled superframe allocation and Guaranteed Time Slot (GTS) latency.
βοΈ Key MATLAB Functions:
treeplotpdist2randtextplot
π Expected Output & Metrics: Packet Delivery Ratio (PDR %) vs beacon order ($BO$) and superframe order ($SO$), duty cycle %, and GTS latency jitter.
nodes_parent = [0 1 1 2 2 3 3 4 5];
figure; [x, y] = treeplot(nodes_parent);
text(x+0.02, y, cellstr(num2str((1:length(nodes_parent))')));
title('ZigBee (IEEE 802.15.4) Cluster-Tree Topology Hierarchy');
24. Wireless Body Area Network (WBAN) IEEE 802.15.6 Thermal-Aware Routing for Healthcare
Intermediate
Toolbox: Communications, Optimization
Deliverables: Code .m, Report
π― Problem & Objective: Simulate on-body and implanted biosensor nodes (ECG, SpO2, EEG) communicating with a central hub. Implement Thermal-Aware Routing (TARA) to divert packets away from overheating nodes and maintain Specific Absorption Rate (SAR) compliance.
βοΈ Key MATLAB Functions:
pdist2scatter3ode45plotdiff
π Expected Output & Metrics: Maximum node temperature rise (< 0.5 Β°C), thermal hotspot avoidance rate, vital sign packet delivery latency, and network longevity.
node_temp = ones(1, 8) * 37.0;
hotspot_threshold = 37.4;
node_temp(3) = node_temp(3) + 0.45;
safe_forwarders = find(node_temp < hotspot_threshold);
fprintf('TARA Active: Node 3 Hotspot Isolated. Safe Next-Hops: %s\n', num2str(safe_forwarders));
25. Deep Reinforcement Learning (Q-Learning) for Dynamic Routing and Packet Scheduling in SDN
Advanced
Toolbox: Reinforcement Learning, Graph Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Implement a Q-learning agent within an SDN controller that dynamically learns optimal packet forwarding policies under fluctuating traffic matrices without prior knowledge of link delays or failure profiles.
βοΈ Key MATLAB Functions:
zerosrandmaxgraphplot
π Expected Output & Metrics: Q-table convergence rate (episodes), cumulative reward curve, average end-to-end packet latency reduction vs static Dijkstra routing.
numNodes = 6; Q = zeros(numNodes, numNodes);
gamma = 0.8; alpha = 0.5; epsilon = 0.1;
R = -10 * ones(numNodes, numNodes);
R(1, [2 3]) = 0; R(2, [1 4 5]) = 0; R(3, [1 5]) = 0;
R(4, [2 6]) = 0; R(5, [2 3 6]) = 0; R(6, 6) = 100;
for episode = 1:500
state = randi(numNodes - 1);
while state ~= 6
valid_actions = find(R(state, :) >= 0);
if rand() < epsilon
action = valid_actions(randi(length(valid_actions)));
else
[~, idx] = max(Q(state, valid_actions));
action = valid_actions(idx);
end
reward = R(state, action);
Q(state, action) = Q(state, action) + alpha * ...
(reward + gamma * max(Q(action, :)) - Q(state, action));
state = action;
end
end
fprintf('Trained Q-Table Optimal Routing Policy Learned Successfully.\n');
26. Content-Centric Networking (CCN) and Named Data Networking (NDN) In-Network Caching
Advanced
Toolbox: Graph Theory & Network Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Implement core Information-Centric Networking (ICN) primitives in MATLAB: Pending Interest Table (PIT), Forwarding Information Base (FIB), and Content Store (CS). Compare Least Recently Used (LRU) and Least Frequently Used (LFU) in-network caching policies.
βοΈ Key MATLAB Functions:
containers.Maprandpermismemberbarplot
π Expected Output & Metrics: Cache hit ratio (%) vs Zipf content popularity skewness parameter $\alpha$, server load reduction, and content retrieval latency.
numContents = 500; alpha = 0.8;
ranks = 1:numContents; zipf_prob = (1 ./ ranks.^alpha) / sum(1 ./ ranks.^alpha);
requests = randsample(numContents, 2000, true, zipf_prob);
cache_size = 50; cache = []; hits = 0;
for req = requests
if ismember(req, cache)
hits = hits + 1;
cache = [req, setdiff(cache, req, 'stable')];
else
if length(cache) >= cache_size, cache(end) = []; end
cache = [req, cache];
end
end
fprintf('NDN LRU In-Network Cache Hit Ratio: %.2f%%\n', (hits / length(requests))*100);
27. Network Lifetime Maximization in WSN using Particle Swarm Optimization (PSO)
Intermediate
Toolbox: Global Optimization, Communications
Deliverables: Code .m, Report
π― Problem & Objective: Formulate an optimization fitness function combining intra-cluster Euclidean distance, residual energy, and sink proximity. Implement Particle Swarm Optimization (PSO) to dynamically select the global optimal subset of Cluster Heads in WSNs.
βοΈ Key MATLAB Functions:
particleswarmpdist2minscatterplot
π Expected Output & Metrics: Network lifetime extension (rounds) vs standard LEACH (+35%), average energy consumption per packet, and fitness convergence history.
numNodes = 100; nodes = rand(numNodes, 2) * 100;
sink = [50, 100]; k_clusters = 5;
fitnessFcn = @(ch_pos) sum(min(pdist2(nodes, reshape(ch_pos, [k_clusters, 2])), [], 2)) + ...
0.5 * sum(pdist2(reshape(ch_pos, [k_clusters, 2]), sink));
opts = optimoptions('particleswarm', 'SwarmSize', 30, 'MaxIterations', 60, 'Display', 'off');
[opt_ch, fval] = particleswarm(fitnessFcn, k_clusters*2, zeros(1, 10), 100*ones(1, 10), opts);
opt_ch_coords = reshape(opt_ch, [k_clusters, 2]);
figure; scatter(nodes(:,1), nodes(:,2), 25, 'b', 'filled'); hold on;
scatter(opt_ch_coords(:,1), opt_ch_coords(:,2), 120, 'r', 'p', 'filled');
plot(sink(1), sink(2), 'ks', 'MarkerSize', 10, 'MarkerFaceColor', 'g');
legend('Sensor Nodes', 'PSO Optimal Cluster Heads', 'Sink');
title('PSO-Optimized WSN Clustering Layout');
28. Fault-Tolerant Routing and Link Failure Recovery in Distributed Mesh Topologies
Intermediate
Toolbox: Graph Theory & Network Algorithms
Deliverables: Code .m, Report
π― Problem & Objective: Model random and correlated node/link failures across enterprise WAN backbones. Implement Fast Reroute (FRR) and independent loop-free backup path tables to achieve sub-millisecond failover recovery.
βοΈ Key MATLAB Functions:
graphrmedgeshortestpathhighlightplot
π Expected Output & Metrics: Failover convergence time (ms), packet loss during transition (0%), alternate path length stretch ratio, and network availability score.
s = [1 1 2 2 3 4 4 5 6];
t = [2 3 3 4 5 5 6 7 7];
w = [2 4 1 3 2 1 4 2 1];
G = graph(s, t, w);
[primary_path, primary_cost] = shortestpath(G, 1, 7);
G_backup = rmedge(G, primary_path(1:end-1), primary_path(2:end));
[backup_path, backup_cost] = shortestpath(G_backup, 1, 7);
fprintf('Primary Path: %s (Cost: %d)\n', num2str(primary_path), primary_cost);
fprintf('Instant FRR Backup Path: %s (Cost: %d)\n', num2str(backup_path), backup_cost);