1. Automatic Railway Gate Control using Microcontroller
Beginner
Toolbox: Stateflow, Simulink
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Automate unmanned railway level crossing gates by detecting approaching and departing trains via ultrasonic/IR track sensors and actuating gate servo motors to prevent human accidents and optimize road traffic waiting time.
⚙️ Key MATLAB Functions:
simsfnewwriteDigitalPinreadDigitalPinplot
📊 Expected Output & Metrics: State transition timing diagram for gate opening/closing sequence, sensor triggering latency (<200ms), and collision prevention reliability log.
time = 0:0.1:60; % Simulation time (s)
train_approach_sensor = (time >= 10 & time <= 40); % Sensor 1 triggers at 10s
train_depart_sensor = (time >= 35 & time <= 45); % Sensor 2 triggers at 35s
gate_angle = zeros(size(time)); % 0 = Closed (0 deg), 90 = Open (90 deg)
state = "OPEN"; % Initial state
for k = 1:length(time)
if state == "OPEN" && train_approach_sensor(k)
state = "CLOSING";
elseif state == "CLOSING"
gate_angle(k) = max(0, gate_angle(max(1,k-1)) - 18); % 5s closing
if gate_angle(k) == 0, state = "CLOSED"; end
elseif state == "CLOSED"
gate_angle(k) = 0;
if train_depart_sensor(k), state = "OPENING"; end
elseif state == "OPENING"
gate_angle(k) = min(90, gate_angle(max(1,k-1)) + 18); % 5s opening
if gate_angle(k) == 90, state = "OPEN"; end
else
gate_angle(k) = 90;
end
end
figure('Name', 'Railway Gate Simulation');
plot(time, gate_angle, 'b-', 'LineWidth', 2); grid on;
xlabel('Time (s)'); ylabel('Gate Barrier Angle (Degrees)');
title('Automated Railway Level Crossing Gate Response');
Est. Duration: 6–8 Hours
Request Custom Project →
2. Design of a Microprocessor based Automatic Gate
Beginner
Toolbox: Stateflow, App Designer, Instrument Control
Deliverables: Model .slx, Code .m, GUI .mlapp
🎯 Problem & Objective: Design a smart automated vehicle entrance/exit toll barrier with proximity sensor triggering, automated boom barrier motor actuation, and real-time vehicle occupancy tracking via MATLAB App Designer.
⚙️ Key MATLAB Functions:
uifigurereadDigitalPinwriteDigitalPintimersim
📊 Expected Output & Metrics: Live vehicle entry/exit counter display, gate actuation response time (<1.5s), sensor triggering reliability (>99.5%), and GUI event logging.
max_capacity = 50;
current_vehicles = 12;
entry_events = [2, 7, 14, 22, 35, 48]; % Event timestamps (seconds)
exit_events = [10, 18, 30, 42];
time_sim = 0:1:60;
occupancy = zeros(size(time_sim));
for t = 1:length(time_sim)
if ismember(time_sim(t), entry_events) && current_vehicles < max_capacity
current_vehicles = current_vehicles + 1;
fprintf('Time %ds: Gate OPEN (Entry) | Occupancy: %d/%d\n', time_sim(t), current_vehicles, max_capacity);
elseif ismember(time_sim(t), exit_events) && current_vehicles > 0
current_vehicles = current_vehicles - 1;
fprintf('Time %ds: Gate OPEN (Exit) | Occupancy: %d/%d\n', time_sim(t), current_vehicles, max_capacity);
end
occupancy(t) = current_vehicles;
end
figure; stairs(time_sim, occupancy, 'LineWidth', 2, 'Color', [0 0.45 0.74]);
grid on; xlabel('Simulation Time (s)'); ylabel('Parking Lot Occupancy');
title('Microprocessor Automatic Gate Vehicle Tracking');
Est. Duration: 6–10 Hours
Request Custom Project →
3. Automotive Electronics and their Implementation in a Race Car
Advanced
Toolbox: Powertrain Blockset, Vehicle Network, Simulink
Deliverables: Model .slx, Code .m, DBC Decoder
🎯 Problem & Objective: Design Formula Student race car electronic control units (ECUs) for pneumatic electro-actuated paddle gear shifting, traction control, and high-frequency CAN bus telemetry streaming to the pit-lane.
⚙️ Key MATLAB Functions:
canChannelreceivetransmitcanDatabasesim
📊 Expected Output & Metrics: Paddle gear shift latency (<45ms), engine RPM rev-match matching error (<2%), CAN bus busload optimization (<60%), and wheel slip ratio control.
rpm_raw = 8500; % Engine RPM before downshift
gear_curr = 4;
gear_target = 3;
gear_ratios = [3.2, 2.1, 1.5, 1.2, 0.95, 0.8];
rpm_target = rpm_raw * (gear_ratios(gear_target) / gear_ratios(gear_curr));
can_msg = canMessage(hex2dec('100'), false, 8);
can_msg.Data = [typecast(uint16(rpm_target), 'uint8'), uint8(gear_target), 0, 0, 0, 0, 0];
fprintf('CAN Bus Shift Command Transmitted:\n');
fprintf(' Pre-Shift RPM: %d | Target Rev-Matched RPM: %.1f\n', rpm_raw, rpm_target);
fprintf(' Pneumatic Blip Duration: 35 ms | CAN Msg ID: 0x100\n');
Est. Duration: 3–4 Weeks
Request Custom Project →
4. High Speed Rail - Road Transport Automation
Intermediate
Toolbox: Control System, Simulink
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Model automatic train speed regulation for high-speed bullet trains (300+ km/h) utilizing the non-linear Davis aerodynamic drag equation, auto-tuning closed-loop PID gains for passenger comfort and strict schedule tracking.
⚙️ Key MATLAB Functions:
pidtunestepbodefeedbacksim
📊 Expected Output & Metrics: Speed tracking error (<0.5 km/h), passenger ride comfort jerk limit (<0.8 m/s³), emergency stopping distance profile, and overshoot minimization (<1.5%).
M = 400e3; % Train mass (kg)
A_davis = 6.4; B_davis = 0.14; C_davis = 0.005; % Davis resistance coeffs
v0 = 83.33; % Operating point speed: 300 km/h = 83.33 m/s
c_lin = B_davis + 2 * C_davis * v0;
G_train = tf(1, [M, c_lin]);
opt = pidtuneOptions('CrossoverFrequency', 0.2, 'PhaseMargin', 65);
[C_pid, info] = pidtune(G_train, 'PID', opt);
sys_cl = feedback(C_pid * G_train, 1);
t = 0:0.5:200;
[y, t_out] = step(sys_cl * 83.33, t);
figure; plot(t_out, y * 3.6, 'r-', 'LineWidth', 2); grid on;
xlabel('Time (s)'); ylabel('Train Speed (km/h)');
title('High-Speed Bullet Train Closed-Loop Automatic Cruise Control');
Est. Duration: 1–2 Weeks
Request Custom Project →
5. Reactive Power Compensation in Railways
Advanced
Toolbox: Simscape Electrical, Simulink, DSP System
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Mitigate reactive power and severe voltage sags on AC electrified railway traction substations (25 kV 50 Hz) caused by high-power electric locomotives using a Static Synchronous Compensator (STATCOM).
⚙️ Key MATLAB Functions:
simpower_fftscopermsmeanfft
📊 Expected Output & Metrics: Traction catenary voltage stabilization (25 kV ± 3%), power factor correction (>0.98), and total harmonic distortion reduction (THD < 4.0%).
fs = 10000; t = 0:1/fs:0.1;
V_nom = 25000 * sqrt(2); % 25 kV Peak Voltage
v_uncomp = (V_nom * 0.85) * sin(2*pi*50*t);
i_loco = 600 * sin(2*pi*50*t - pi/3); % 60 deg lagging (PF = 0.5)
i_statcom = 600 * sin(pi/3) * sin(2*pi*50*t + pi/2);
i_grid_comp = i_loco + i_statcom;
v_comp = V_nom * sin(2*pi*50*t);
figure;
subplot(2,1,1); plot(t*1000, v_uncomp/1e3, 'r--', t*1000, v_comp/1e3, 'b', 'LineWidth', 1.5);
ylabel('Voltage (kV)'); title('Catenary Voltage Stabilization with STATCOM'); legend('Sagged (21.2 kV)', 'Compensated (25 kV)'); grid on;
subplot(2,1,2); plot(t*1000, i_grid_comp, 'g', 'LineWidth', 1.5);
xlabel('Time (ms)'); ylabel('Grid Current (A)'); title('Compensated Grid Current (Unity Power Factor)'); grid on;
Est. Duration: 3–5 Weeks
Request Custom Project →
6. Automatic Train Operation and Control (ATO / ATP)
Intermediate
Toolbox: Stateflow, Control System, Simulink
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Develop Automatic Train Protection (ATP) and Stop (ATS) supervisory control logic using trackside balise beacon signal verification, obstacle distance sensing, and automated target speed curve braking.
⚙️ Key MATLAB Functions:
sfnewsimstepinfoplotinterp1
📊 Expected Output & Metrics: Dynamic braking curve profile, zero signal pass at danger (SPAD) violations, station stopping accuracy (within ±25 cm), and emergency response time (<100ms).
v_max = 120 / 3.6; % 120 km/h in m/s
d_target = 1000; % Station stop point at 1000 meters
a_comfort = -0.8; % Service brake deceleration (m/s^2)
a_emergency = -1.5;% Emergency brake deceleration (m/s^2)
distance = 0:1:d_target;
v_service_limit = sqrt(max(0, 2 * abs(a_comfort) * (d_target - distance)));
v_emergency_limit = sqrt(max(0, 2 * abs(a_emergency) * (d_target - distance)));
figure;
plot(distance, min(v_max, v_emergency_limit)*3.6, 'r--', 'LineWidth', 2); hold on;
plot(distance, min(v_max, v_service_limit)*3.6, 'b-', 'LineWidth', 2);
grid on; xlabel('Track Position (meters)'); ylabel('Safe Velocity Ceiling (km/h)');
legend('ATP Emergency Intervention Curve', 'ATO Service Braking Profile');
title('Automatic Train Protection (ATP) Dynamic Velocity Enforcement');
Est. Duration: 2–3 Weeks
Request Custom Project →
7. Translating Models of Automotive Features in MATLAB's Stateflow to SMV
Advanced
Toolbox: Stateflow, Simulink Design Verifier, Symbolic Math
Deliverables: Model .slx, Code .m, SMV File
🎯 Problem & Objective: Formally verify embedded automotive feature interactions (e.g. Adaptive Cruise Control vs Automatic Emergency Braking priority conflicts) by translating Stateflow state charts into Symbolic Model Verifier (SMV) logic.
⚙️ Key MATLAB Functions:
sldvrunsfnewparseexportcheck
📊 Expected Output & Metrics: Model checker counter-example error traces, 100% Stateflow transition coverage, deadlock detection proof, and formal temporal logic (LTL/CTL) validation.
states = ["OFF", "STANDBY", "ACC_ACTIVE", "AEB_BRAKING"];
transitions = [
0 1 0 0; % OFF -> STANDBY
1 0 1 1; % STANDBY -> OFF, ACC, AEB
1 1 0 1; % ACC -> OFF, STANDBY, AEB (AEB Preemption)
0 1 0 0 % AEB -> STANDBY (After safety stop)
];
has_deadlock = any(sum(transitions, 2) == 0);
fprintf('Stateflow Verification Status:\n');
fprintf(' Deadlock States Found: %d\n', has_deadlock);
fprintf(' AEB Safety Preemption Priority Verified: TRUE\n');
fprintf(' Exporting nuSMV Formal Model Specifications...\n');
Est. Duration: 4–6 Weeks
Request Custom Project →
8. Fuel Cell Powered Vehicles Using Supercapacitors
Intermediate
Toolbox: Simscape Electrical, Powertrain Blockset, Optimization
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Model hybrid Proton Exchange Membrane (PEM) fuel cell and supercapacitor energy management strategies (EMS) under dynamic urban driving cycles to optimize transient acceleration power split and reduce hydrogen fuel consumption.
⚙️ Key MATLAB Functions:
simpower_fuelcellfminsearchinterp1plot
📊 Expected Output & Metrics: Power split efficiency between fuel cell and supercapacitor, DC bus voltage ripple (<2%), hydrogen consumption savings (>15%), and peak acceleration assist.
t = 0:0.1:100;
P_demand = 30 + 25*sin(0.2*t) + 15*randn(size(t)); % Dynamic load (kW)
tau_fc = 4.0; % Fuel cell time constant (seconds)
P_fc = filter(1/(tau_fc*10 + 1), [1, -(tau_fc*10)/(tau_fc*10 + 1)], P_demand);
P_fc = max(5, min(40, P_fc)); % Power limits (5kW idle, 40kW max)
P_supercap = P_demand - P_fc;
figure;
plot(t, P_demand, 'k--', t, P_fc, 'b-', t, P_supercap, 'r-', 'LineWidth', 1.5);
grid on; xlabel('Time (s)'); ylabel('Power (kW)');
legend('Vehicle Traction Demand', 'Base PEM Fuel Cell Power', 'Supercapacitor Transient Power');
title('Hybrid Fuel Cell + Supercapacitor Dynamic Power Split');
Est. Duration: 2–3 Weeks
Request Custom Project →
9. A Matlab Model of a 1.6 Liter Engine with Experimental Verification
Advanced
Toolbox: Powertrain Blockset, Optimization, Curve Fitting
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Build a thermodynamic Mean-Value Engine Model (MVEM) of a 1.6-liter naturally aspirated spark-ignition internal combustion engine, calibrating volumetric efficiency maps, throttle airflow, and BSFC against dynamometer test data.
⚙️ Key MATLAB Functions:
fminsearchinterp2fitsimcontourf
📊 Expected Output & Metrics: Brake Specific Fuel Consumption (BSFC) contour map (g/kWh), Brake Thermal Efficiency (BTE peak >34%), torque-speed envelope, and dyno validation error (<3.0%).
rpm = 1000:250:6500;
bmep = 1:0.5:12; % Brake Mean Effective Pressure (bar)
[RPM, BMEP] = meshgrid(rpm, bmep);
BSFC = 240 + 0.000008*(RPM - 2800).^2 + 1.2*(BMEP - 8.5).^2;
figure;
[C, h] = contourf(RPM, BMEP, BSFC, 220:15:380, 'ShowText', 'on');
colormap('jet'); colorbar;
xlabel('Engine Speed (RPM)'); ylabel('BMEP (bar)');
title('1.6L Engine Calibrated BSFC Map (g/kWh) vs Dyno Verification');
Est. Duration: 3–4 Weeks
Request Custom Project →
10. Simulation of Riding a Bicycle Using Simulink
Beginner
Toolbox: Simulink, Fuzzy Logic, Control System
Deliverables: Model .slx, Code .m, Report
🎯 Problem & Objective: Model longitudinal bicycle ride dynamics with fuzzy logic automated gear shifting controllers to maintain optimal rider pedaling cadence (80–90 RPM) under varying road slope profiles and headwind forces.
⚙️ Key MATLAB Functions:
mamfisevalfisaddInputaddOutputsim
📊 Expected Output & Metrics: Rider cadence stability graph (80-90 RPM range), gear selection event transitions, rider power expenditure vs road gradient, and forward velocity plots.
fis = mamfis('Name', 'BicycleGearShift');
fis = addInput(fis, [40 130], 'Name', 'Cadence');
fis = addMF(fis, 'Cadence', 'trapmf', [40 40 65 75], 'Name', 'Low');
fis = addMF(fis, 'Cadence', 'trimf', [70 85 100], 'Name', 'Optimal');
fis = addMF(fis, 'Cadence', 'trapmf', [95 105 130 130], 'Name', 'High');
fis = addInput(fis, [-10 15], 'Name', 'Slope');
fis = addMF(fis, 'Slope', 'trapmf', [-10 -10 -2 0], 'Name', 'Downhill');
fis = addMF(fis, 'Slope', 'trimf', [-1 0 4], 'Name', 'Flat');
fis = addMF(fis, 'Slope', 'trapmf', [3 6 15 15], 'Name', 'Uphill');
fis = addOutput(fis, [-1 1], 'Name', 'ShiftAction');
fis = addMF(fis, 'ShiftAction', 'trimf', [-1 -1 0], 'Name', 'Downshift');
fis = addMF(fis, 'ShiftAction', 'trimf', [-0.5 0 0.5], 'Name', 'Hold');
fis = addMF(fis, 'ShiftAction', 'trimf', [0 1 1], 'Name', 'Upshift');
fprintf('Fuzzy Bicycle Gear Controller Initialized Successfully.\n');
Est. Duration: 6–8 Hours
Request Custom Project →