Robotics, automation, MATLAB and practical coding
Selected work covering industrial automation support, COBOT and vision-system activity, MATLAB robotics simulation, and static website development.
Provided industrial automation support during my placement year at Caterpillar, covering COBOT and vision-system activity in a live manufacturing environment. The work focused on production support, fault investigation, validation activity and inspection reliability for automated systems.
Published details are limited to tools, techniques and transferable engineering work. Site-specific architecture, layouts, images, production data, equipment locations and internal documentation are excluded.
Work included support for automated inspection systems, COBOT-related production issues, fault investigation, issue logging, root-cause and corrective-action activity, and coordination with internal and external stakeholders.
The work sat at the interface between manufacturing engineering, automation, quality and technical support. The main objective was to improve confidence in automated systems while reducing avoidable production disruption.
No site-specific images, system architecture, layouts, line details, equipment locations, production rates or internal documents are published. Any future images will be self-made diagrams or public/licensed generic imagery only.
MATLAB implementation of a Rapidly-exploring Random Tree path-planning simulation using an office floor-plan environment. The project demonstrates map loading, obstacle representation, Dubins state-space planning, occupancy-map validation and path generation through a constrained workspace.
The simulation was developed in MATLAB using Robotics System Toolbox functions. Published evidence includes the generated figure and the visible source-code excerpt.
The script loads a predefined occupancy-map environment, applies obstacle data, defines a Dubins vehicle state space and uses an RRT planner to search for a route between the start and goal states. The resulting tree expansion and final path are plotted over the office floor plan.
The output figure shows the obstacle field, tree exploration and final planned path. The MATLAB source code is shown alongside the generated output.
clc;
clear all;
%% Section 1 - Laying out the floor plan
load exampleMaps.mat
whos *Map*
map = binaryOccupancyMap(complexMap, 2);
robotRadius = 0.2;
inflateRadius = 0.1;
mapInflated = copy(map);
inflate(mapInflated, inflateRadius);
% Adding obstacles
x = [12.0; 16.5; 10.0; 13.0; 23.0];
y = [8.0; 9.0; 5.0; 2.0; 12.0];
setOccupancy(map, [x y], ones(5, 1));
show(mapInflated)
%% Section 2 - StateSpaceDubins
stateSpace = stateSpaceDubins;
sv = validatorOccupancyMap(stateSpace);
sv.Map = map;
turningRadius = 0.1;
stateBounds = [0, 24; 0, 22; -pi, pi];
stateSpace.StateBounds = stateBounds;
%% Section 3 - RRT Programme
start = [2, 2, 0];
goal = [24, 15, 0];
planner = plannerRRT(stateSpace, sv, MaxConnectionDistance = 0.2);
rng(100, 'twister');
[pthObj, solnInfo] = plan(planner, start, goal);
show(map)
grid on;
title('Office Floor Plan')
hold on
plot(solnInfo.TreeData(:, 1), solnInfo.TreeData(:, 2), '.-')
plot(pthObj.States(:, 1), pthObj.States(:, 2), 'r-', 'LineWidth', 2)A vanilla JavaScript reimplementation of the same algorithm, running live in the browser with no dependencies. Click the canvas once to reposition the start marker, again to reposition the goal, then press Run. The tree expansion is deterministic for a given seed.
iterations 0 nodes 1 status: idle
A three-station accumulation conveyor simulated in the browser and controlled by a virtual PLC. The scan cycle, ladder logic, timers, counters, sealing circuits, and station-to-station handshakes are all implemented to standard PLC conventions. Every 100 ms the controller reads its simulated photoeye inputs, solves the ladder, and writes motor outputs that move the items on the HMI.
A separate item-tracking layer runs alongside the ladder. It keeps hold of each item's identity and type as it moves between stations, and it checks four runtime invariants every scan. If any invariant fails, the PLC faults and the line stops. This is how real conveyors catch sensor bounce, missing product, and broken handshakes before they corrupt downstream processes.
(* IEC 61131-3 Structured Text — same logic as the ladder view *)
(* R1: Safety enable — E-Stop clear AND Reset arms the system *)
IF NOT EStop_NC THEN
Sys_Enabled := FALSE;
Sys_Running := FALSE;
ELSIF Reset_PB THEN
Sys_Enabled := TRUE;
END_IF;
(* R2: Master sealing circuit — classic Start/Stop with seal-in *)
IF Sys_Enabled AND (Start_PB OR Sys_Running)
AND Stop_PB_NC AND NOT Sys_Faulted THEN
Sys_Running := TRUE;
ELSIF NOT Stop_PB_NC OR NOT Sys_Enabled OR Sys_Faulted THEN
Sys_Running := FALSE;
END_IF;
(* Downstream-ready evaluation *)
S1_AcceptAck := (Station2_Owner = NULL) AND NOT S2_Backup AND NOT Break_HS_S1S2;
S2_AcceptAck := (Station3_Owner = NULL) AND NOT S3_Backup AND NOT Break_HS_S2S3;
S3_AcceptAck := Reject_Ready;
(* R6-R8: Backup detection — item at photoeye, downstream not accepting, for PT=2s *)
TON_S1_Backup(IN := S1_Photoeye AND NOT S1_AcceptAck, PT := T#2s);
TON_S2_Backup(IN := S2_Photoeye AND NOT S2_AcceptAck, PT := T#2s);
TON_S3_Backup(IN := S3_Photoeye AND NOT S3_AcceptAck, PT := T#2s);
S1_Backup := TON_S1_Backup.Q;
S2_Backup := TON_S2_Backup.Q;
S3_Backup := TON_S3_Backup.Q;
(* R3-R5: Station motor coils — run only if healthy and downstream ready *)
S1_Motor := Sys_Running AND NOT Sys_Faulted AND S1_AcceptAck;
S2_Motor := Sys_Running AND NOT Sys_Faulted AND S2_AcceptAck;
S3_Motor := Sys_Running AND NOT Sys_Faulted AND S3_AcceptAck;
(* R9-R11: Slip alarm — motor commanded but no encoder motion for PT=500ms *)
TON_S1_Slip(IN := S1_Motor AND NOT S1_Enc_Pulse, PT := T#500ms);
TON_S2_Slip(IN := S2_Motor AND NOT S2_Enc_Pulse, PT := T#500ms);
TON_S3_Slip(IN := S3_Motor AND NOT S3_Enc_Pulse, PT := T#500ms);
IF TON_S1_Slip.Q THEN Sys_Faulted := TRUE; Fault_Code := 11; END_IF;
IF TON_S2_Slip.Q THEN Sys_Faulted := TRUE; Fault_Code := 12; END_IF;
IF TON_S3_Slip.Q THEN Sys_Faulted := TRUE; Fault_Code := 13; END_IF;
(* R12: Throughput counter *)
CTU_Throughput(CU := S3_Photoeye_Falling AND (S3_Item.type = 'A'),
R := Reset_PB, PV := 9999);
(* R13: Reject actuator *)
Reject_Actuator := S3_Photoeye AND (S3_Item.type = 'B') AND Reject_Ready;
(* --- Runs alongside the ladder above --- *)
(* Item-tracking FB maintains Station_Owner[1..3] and item metadata *)
(* (id, type, entry_scan) on photoeye edges. Runtime invariants (no dup IDs, *)
(* count conserved, PE matches owner, zone non-regressing) trip Sys_Faulted *)
(* with a dedicated code so operators distinguish physical faults from *)
(* tracking desync requiring reconciliation. *)
This portfolio was built using HTML, CSS, and Javascript to present engineering evidence in a structured, maintainable and controlled format. The websites code, structure, and architecture may be viewed by pressing f12. To ensure all animations work on Windows OS, please go to Settings > Accessibility > Visual Effects > Toggle "Animation effects".
search-index.json and back.
Seven live pages (Home, About, Experience, CAD, Manufacturing, Robotics
& Automation, Dissertation), a shared stylesheet, and separate
images/, documents/ and videos/
trees organised by project. Every page uses the same header, navigation
and footer template for consistency.
Shared responsive navigation with hover dropdowns for the CAD, Manufacturing, and Robotics & Automation project groups. Layout uses CSS Grid and Flexbox for evidence grids, project cards, and the side-by-side figure/code display used on this page.
Media is organised per project (images, PDFs, and short MP4 loops for CAD demonstrations). Reports are linked directly as PDFs with visible preview images and captions. Alt text and figure captions are applied consistently for accessibility and clarity.
Industrial content is filtered before publication: no employee names, internal architecture, site-specific images, production rates, equipment locations or confidential drawings are shown. Approved screenshots and loops use visible captions and disclaimers.
The below dashboard is an example of consuming a third-party engineering API from the browser and rendering the response as an inline visualisation. The dynamic dashboard makes live requests to the UK National Grid ESO's public Carbon Intensity API on page load and refreshes every five minutes, showing the current grid carbon intensity, the last 24 hours as a sparkline, and the real-time generation mix by fuel type. It is written in vanilla JavaScript with no charting library, degrades gracefully when the API is unreachable, and demonstrates the same principles used when integrating SCADA, MES or IIoT feeds in a manufacturing setting.
|
300
200
100
0
gCO₂/kWh
|
|
|
24h ago
12h ago
now
|
|
| Time | |
|
VERY LOW (<100)
LOW (100–199)
MODERATE (200–299)
HIGH ≥300 clips above chart
|
/intensity/date returns the last 24 hours of
half-hourly readings for the sparkline, and /generation returns the current mix
by fuel type.