Arduino MATLAB Projects (18+ Ideas with Hardware-in-the-Loop & Code)

% Connect Arduino and configure digital pin
a = arduino('COM3', 'Uno');
configurePin(a, 'D2', 'DigitalInput');
configurePin(a, 'D8', 'DigitalOutput');

disp('Listening for IR Remote Signals...');
while true
    if readDigitalPin(a, 'D2') == 0  % Active Low IR pulse detected
        writeDigitalPin(a, 'D8', 1); % Toggle Status LED
        disp('IR Signal Decoded: Command Executed');
        pause(0.2);
        writeDigitalPin(a, 'D8', 0);
    end
end

% Initialize Arduino & Real-Time Live Plot
a = arduino('COM3', 'Uno');
figure('Name', 'Real-Time ADC Telemetry', 'Color', 'w');
hLine = plot(nan, nan, 'b-', 'LineWidth', 1.8);
grid on; xlabel('Sample'); ylabel('Voltage (V)');
ylim([0 5.2]);

voltageData = zeros(1, 200);
for k = 1:200
    voltageData(k) = readVoltage(a, 'A0');
    set(hLine, 'XData', 1:k, 'YData', voltageData(1:k));
    drawnow limitrate;
end

% Connect Arduino I2C Color Sensor
a = arduino('COM3', 'Uno', 'Libraries', 'I2C');
colorSensor = i2cdev(a, '0x29'); % TCS34725 Address

% Enable Sensor & Read RGB Channels
write(colorSensor, hex2dec('80'), hex2dec('03')); % Power ON
data = read(colorSensor, 8, 'uint8');
clear = double(bitshift(data(2),8) + data(1));
red   = double(bitshift(data(4),8) + data(3)) / clear;
green = double(bitshift(data(6),8) + data(5)) / clear;
blue  = double(bitshift(data(8),8) + data(7)) / clear;

rgb_normalized = min(max([red, green, blue], 0), 1);
lab_val = rgb2lab(rgb_normalized);
fprintf('Normalized RGB: [%.2f, %.2f, %.2f] | Lab: [%.1f, %.1f, %.1f]\n', ...
    rgb_normalized, lab_val);

% 3D Point Cloud Registration for Spacecraft Pose Estimation
fixedCloud  = pcread('cubesat_cad_model.ply');
movingCloud = pointCloud(rand(500, 3)*0.5); % Streamed from ToF Sensor

% Iterative Closest Point (ICP) 6-DOF Alignment
[tform, regCloud, rmse] = pcregistericp(movingCloud, fixedCloud, ...
    'Metric', 'planeToPlane', 'MaxIterations', 50);

fprintf('Docking Pose Estimation RMSE: %.4f m\n', rmse);
disp('Translation Vector (X, Y, Z):');
disp(tform.Translation);

% Path Planning & Pure Pursuit Navigation
map = binaryOccupancyMap(20, 20, 10);
setOccupancy(map, [5 5; 5 6; 5 7; 10 12], 1);
planner = plannerAStar(map);

startPose = [2, 2]; goalPose = [15, 18];
path = plan(planner, startPose, goalPose);

controller = controllerPurePursuit;
controller.Waypoints = path;
controller.DesiredLinearVelocity = 0.4; % m/s
controller.LookaheadDistance = 0.5;

disp('Trajectory Computed: Ready for Arduino Motion Execution');

% 5-Channel Digital Stethoscope Signal Filtering
Fs = 2000; % 2 kHz ADC Sampling Rate
bpFilt = designfilt('bandpassiir', 'FilterOrder', 4, ...
    'HalfPowerFrequency1', 20, 'HalfPowerFrequency2', 250, ...
    'SampleRate', Fs);

% Zero-phase filtering of PCG acoustic stream
raw_pcg = readVoltage(a, 'A1'); % Live Stream from Arduino
clean_pcg = filtfilt(bpFilt, raw_pcg);
[pks, locs] = findpeaks(clean_pcg, 'MinPeakDistance', Fs*0.4);

fprintf('Detected Heart Rate: %.1f BPM\n', length(pks)*60 / (length(raw_pcg)/Fs));

% Leader-Follower Swarm Formation Control
numBots = 3;
leaderPose = [5.0, 5.0, pi/4];
offsetAngles = [-pi/3, pi/3]; distance = 1.0;

for i = 1:2
    followerTarget(i, 1) = leaderPose(1) - distance*cos(leaderPose(3) + offsetAngles(i));
    followerTarget(i, 2) = leaderPose(2) - distance*sin(leaderPose(3) + offsetAngles(i));
    fprintf('Bot %d Target: (%.2f, %.2f)\n', i+1, followerTarget(i, 1), followerTarget(i, 2));
end

% Cloud Gas Analytics & Threshold Detection
channelID = 123456; readKey = 'THINGSPEAK_READ_KEY';
[data, timeStamps] = thingSpeakRead(channelID, 'Fields', [1, 2, 3], ...
    'NumPoints', 100, 'ReadKey', readKey);

ch4_ppm = data(:, 1); co_ppm = data(:, 2); temp_c = data(:, 3);
% Anomaly Detection & Early Hazard Alarm
hazardIdx = find(ch4_ppm > 1000 | co_ppm > 50);
if ~isempty(hazardIdx)
    warning('EMERGENCY HAZARD: Gas Limit Exceeded in Zone %d', hazardIdx(end));
end

% Fixed-Point HDL Code Generation for Matrix Multiplication
hdlCfg = coder.config('hdl');
hdlCfg.TargetLanguage = 'VHDL';
hdlCfg.GenerateHDLTestBench = true;

% Define Fixed-Point Types: signed 16-bit word, 8-bit fraction
T = numerictype(1, 16, 8);
F = fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Wrap');
A_fi = fi(randn(4,4), T, F);
B_fi = fi(randn(4,4), T, F);

codegen -config hdlCfg matrix_mult_hdl -args {A_fi, B_fi};

% NSGA-II Multi-Objective Powertrain Optimization
opts = optimoptions('gamultiobj', 'PopulationSize', 50, ...
    'MaxGenerations', 100, 'PlotFcn', @gaplotpareto);

nvars = 3; % [GearRatio, BatteryPackCells, MotorPeakTorque]
lb = [4.0, 80, 150]; ub = [12.0, 140, 450];
[xOpt, fval] = gamultiobj(@bev_objective_fun, nvars, [], [], [], [], lb, ub, opts);

disp('Optimal Pareto Solutions (Energy vs Accel):');
disp(fval(1:5, :));

% Experimental DC Motor PID Speed Loop
a = arduino('COM3', 'Uno', 'Libraries', 'RotaryEncoder');
enc = rotaryEncoder(a, 'D2', 'D3', 360); % 360 CPR Encoder

Kp = 1.85; Ki = 0.65; Kd = 0.08;
target_rpm = 150; integral_err = 0; prev_err = 0;

for k = 1:300
    current_pos = readCount(enc);
    measured_rpm = (current_pos / 360) * 60 / 0.02; % 20ms delta
    resetCount(enc);
    
    error = target_rpm - measured_rpm;
    integral_err = integral_err + error * 0.02;
    derivative = (error - prev_err) / 0.02;
    pwm_cmd = min(max((Kp*error + Ki*integral_err + Kd*derivative)/255, 0), 1);
    
    writePWMDutyCycle(a, 'D9', pwm_cmd);
    prev_err = error;
    pause(0.02);
end

% 180-Degree Servo Ultrasonic Radar Sweep
a = arduino('COM3', 'Uno', 'Libraries', {'Servo', 'Ultrasonic'});
s = servo(a, 'D9');
u = ultrasonic(a, 'D12', 'D13');

figure('Name', 'Ultrasonic Radar Screen', 'Color', 'k');
angles = linspace(0, pi, 90);
ranges = zeros(1, 90);

for i = 1:90
    writePosition(s, (i-1)/89); % Sweep 0 to 180 deg
    ranges(i) = readDistance(u) * 100; % Distance in cm
    polarplot(angles(1:i), ranges(1:i), 'g-o', 'LineWidth', 1.5);
    rlim([0 200]); thetalim([0 180]); drawnow;
end

% Read Sensors & Stream to ThingSpeak IoT Cloud
channelID = 987654; writeKey = 'THINGSPEAK_WRITE_API_KEY';

temp_C = 26.4; humidity_pct = 58.2; pressure_hPa = 1013.25;
dew_point = temp_C - ((100 - humidity_pct)/5);

thingSpeakWrite(channelID, [temp_C, humidity_pct, pressure_hPa, dew_point], ...
    'Fields', [1, 2, 3, 4], 'WriteKey', writeKey);

disp('Weather Telemetry Successfully Pushed to ThingSpeak');

% 6-DOF IMU Complementary & Kalman Filter Fusion
dt = 0.01; alpha = 0.98; pitch = 0;
a = arduino('COM3', 'Uno', 'Libraries', 'I2C');
imu = mpu6050(a);

for k = 1:500
    [accel, gyro] = read(imu);
    accel_pitch = atan2d(accel(2), sqrt(accel(1)^2 + accel(3)^2));
    gyro_rate   = gyro(1); % deg/s
    
    % Complementary Filter Fusion
    pitch = alpha * (pitch + gyro_rate * dt) + (1 - alpha) * accel_pitch;
    % LQR Actuation Effort Computation
    u_pwm = - (14.2 * (pitch*pi/180) + 2.8 * (gyro_rate*pi/180));
end

% Dual-Axis Sun Tracking Algorithm
a = arduino('COM3', 'Uno', 'Libraries', 'Servo');
servoAzimuth   = servo(a, 'D9');
servoElevation = servo(a, 'D10');

% Read 4 LDR Light Intensities
topL = readVoltage(a, 'A0'); topR = readVoltage(a, 'A1');
botL = readVoltage(a, 'A2'); botR = readVoltage(a, 'A3');

avgTop = (topL + topR)/2; avgBot = (botL + botR)/2;
avgLeft = (topL + botL)/2; avgRight = (topR + botR)/2;

if abs(avgTop - avgBot) > 0.1
    disp('Adjusting Elevation Angle...');
end

% Dual-Wavelength PPG Blood Oxygen Saturation Estimation
fs = 100; % 100 Hz Sampling
red_ac = detrend(red_raw); ir_ac = detrend(ir_raw);
ratio_of_ratios = (std(red_ac) / mean(red_raw)) / (std(ir_ac) / mean(ir_raw));

% Empirical Empirical Calibration Curve
SpO2 = 110 - 25 * ratio_of_ratios;
[pks, locs] = findpeaks(ir_ac, 'MinPeakDistance', fs*0.5);
BPM = length(pks) * 60 / (length(ir_ac)/fs);

fprintf('Vital Signs: Heart Rate = %.1f BPM | SpO2 = %.1f%%\n', BPM, SpO2);

% 4-DOF Robotic Arm Inverse Kinematics Mapping
robot = loadrobot('kinovaGen3', 'DataFormat', 'row');
ik = inverseKinematics('RigidBodyTree', robot);

% Read Gesture Glove Flex Sensor & Map to Cartesian Coordinates
flex_val = readVoltage(a, 'A0'); % Finger Flex Voltage
targetPos = [0.4, 0.2, 0.1 + (flex_val/5)*0.3];
targetTform = trvec2tform(targetPos);

[configSol, solInfo] = ik('EndEffector_Link', targetTform, ones(1,6), robot.homeConfiguration);
disp('Joint Servo Angles Computed Successfully');

% Thermal Chamber Closed-Loop PID Temperature Control
a = arduino('COM3', 'Uno');
setpoint_C = 37.0; % Target Incubation Temp (37°C)
Kp = 0.15; Ki = 0.02; integral_term = 0;

for t = 1:600
    volt = readVoltage(a, 'A0'); % LM35: 10 mV / °C
    current_temp = volt * 100;
    
    error = setpoint_C - current_temp;
    integral_term = min(max(integral_term + error*0.5, -10), 10);
    pwm_duty = min(max(Kp*error + Ki*integral_term, 0), 1);
    
    writePWMDutyCycle(a, 'D9', pwm_duty);
    pause(0.5);
end