NeuralNexus Arm: a 6-DOF Arm Built from Scratch, from CAD to Digital Twin

📌 What this guide covers

This build breaks from the pattern of the other guides here: it is not a copy of an existing open-source arm. The mechanics, the firmware, the kinematics, the digital twin and the vision pipeline were all built from scratch — no kit, no off-the-shelf motion stack. The project has a single thesis: one command makes the physical arm and its 3D digital twin move together.

Because the authors (Lasan Perera and four co-authors) carried the whole chain through, it works extremely well as a textbook for what a robot arm is actually made of: SolidWorks CAD → Simscape Multibody digital twin → MATLAB inverse kinematics → USB CDC at 115200 → STM32H743 real-time servo loop → six steppers plus a servo gripper → AS5047P absolute encoder feedback.

The guide runs system chain → hardware stack → joint transmission → control & protocol → digital twin → vision → downloads → pitfalls. The value is not "build this exact machine" but learning how each layer interfaces and how to verify it.

🧭 Part 1: the system chain (understand the data flow first)

Hold this chain in mind and every later section snaps into place: the host solves the kinematics, sends joint angles over serial, and the MCU does the real-time servo work. A deliberately minimal text protocol decouples the two sides, so each can be developed and debugged alone.

SolidWorks CAD  ->  Simscape Multibody digital twin  ->  MATLAB inverse-kinematics solve
                                     |
                        USB CDC @ 115200 baud (joint-angle text protocol)
                                     v
        STM32H743 @ 420 MHz  ->  6 stepper motors + gripper servo (2 kHz control loop)
                                     |
                    AS5047P absolute encoders (SPI feedback, 14 bit)
                                     |
        Browser Web Serial control panel (Chrome / Edge, no MATLAB license needed)

• Geometry layer: SolidWorks bodies imported into Simscape Multibody as a rigid-body tree (importrobot('Assem1')); link dimensions and joint limits are defined here.
• Planning layer: MATLAB solves IK with the Robotics System Toolbox inverseKinematics solver, producing six joint angles.
• Transport layer: six comma-separated angles plus newline over a USB CDC virtual COM port, 115200 8N1.
• Execution layer: the STM32H743 advances all six axes inside a TIM6 interrupt at 2 kHz; the gripper runs on 50 Hz PWM.
• Feedback layer: six AS5047P magnetic encoders read over SPI1 (mode 1, 14 bit) for verification and future closed-loop work.
• Alternative entry point: no MATLAB install? The project ships a browser control panel that talks to the serial port directly via the Web Serial API.

🔧 Part 2: the hardware stack (selection logic beats part numbers)

⚙️ Part 3: joints, gearing and pulse scaling

🖥️ Part 4: the serial protocol and control options

On the host side you have two options: a MATLAB session (solve IK, drive the twin, send angles) or the browser control panel (open the HTML in Chrome / Edge, click Connect, pick the COM port — no MATLAB license required). The standard MATLAB opening sequence is below; the very first step must create jointData, because the Simscape From Workspace blocks depend on it:

% Run this block at the start of every MATLAB session
jointData = zeros(2,7);            % must exist before loading the model
load_system('Assem1');
robot = importrobot('Assem1');
robot.DataFormat = 'row';
limitsDeg = [-180 180; -70 70; 120 240; -180 180; 60 300; -180 180];
for i = 1:6
    robot.Bodies{i}.Joint.PositionLimits = deg2rad(limitsDeg(i,:));
end
ik = inverseKinematics('RigidBodyTree', robot);
weights = [1 1 1 1 1 1];
q0 = homeConfiguration(robot);
s  = serialport("COM9", 115200);   % check Device Manager for the real port

% Typical actions
armIK(robot, ik, weights, q0)                         % interactive IK slider tool
goToXYZ(robot, ik, weights, q0, [-0.15 0.30 0.10], s) % XYZ to hardware + synced twin
moveBoth(s, [0 10 0 0 0 0])                           % move hardware and sim together
armWave(s)                                            % wave routine
writeline(s, "HOME")                                  % encoder homing

🧪 Part 5: the digital twin and the demos

The Simscape Multibody model in Mechanics Explorer is a full-size copy of the real arm. Every time MATLAB solves IK it writes joint angles into jointData, the From Workspace blocks read that two-column time table and drive the six revolute joints — press Run and the on-screen arm performs the same motion as the hardware on the bench.

• Position lock: the tip holds a fixed point in space while the tool orientation sweeps, showing how the links reconfigure around a locked end effector.
• Orientation lock + XYZ sweep: the tool angle is held while the tip sweeps along X, Y and Z in turn.
• Motion library: vertical square, wave and pick-and-place sequences are recorded (drawSquare.m / armWave.m / objectPicking.m and friends).
• Nullspace demo: nullspaceDemo.m changes the joint configuration at a fixed end-effector pose — a hands-on look at the arm's kinematic redundancy.
• Scripted runs: set_param('Assem1','SimulationCommand','start') starts the simulation from code, which is handy for batch checks.

👁️ Part 6: the vision pipeline (pixels → world coordinates → IK)

📥 Downloads (full official mirror, no VPN needed)

Everything below is a mirror of the original repository files, grouped by purpose and downloadable directly. Total: 248 files / about 27.7 MB.

docs · reports and presentations (EDR Documentation)

schematics · electrical

gerber · PCB fabrication files

eda · EasyEDA (LCEDA) Pro project (added by this site · editable source)

ik-matlab · MATLAB / Simscape project and models

vision · scripts and calibration data

firmware · STM32H743 project (170 files / 11.8 MB)

🚀 Part 7: quick start (three steps to a first motion)

1. Firmware: import firmware/ into STM32CubeIDE (the .launch config is included) → build → flash via ST-Link → confirm the board enumerates as a USB virtual COM port. If you regenerate code from CubeMX, comment out MX_SDMMC1_SD_Init() again — with no SD card inserted it drops straight into Error_Handler() and the board hangs at boot.
2. Host: open ik-matlab/ in MATLAB and follow section 0 of GUIDE.txt (jointData → importrobot → joint limits → IK solver → serial), then run goToXYZ or armIK.
3. No-MATLAB route: open the official control panel HTML in Chrome / Edge → Connect arm → choose the port → send angles directly. Run clear s first to release the port from MATLAB, otherwise it will not open.

🐛 Part 8: pitfalls (the section that saves the most time)

• The encoder "ghost drift" was a -1 sentinel. Failed reads returned -1, those values went into a 30-sample average, and a stationary joint appeared to swing 60–70° — the sensor was always fine. Filter -1 before averaging and repeatability returns to ±0.01°. The giveaway: it got worse at lower speed, whereas genuine signal-integrity problems always improve when you slow down.
• Retiming an ISR can scale things wrong by 25×. Moving from 50 kHz to 2 kHz left dt = 0.00002 and stepInterval = 50000/speed, so every motor crawled. Correct values are dt = 0.0005 and stepInterval = 2000/speed.
• Home with raw motor indices. Stepper_MoveAll() (no jointDir) is the correct call; using joint indices produces a two-way sign flip.
• Send long moves in 10° chunks so nothing is interrupted, without touching the firmware.
• Telemetry or handshake, never both: periodic prints swallow the handshake packet.
• One mate pair per Simscape joint: any extra parallel or perpendicular mate locks the revolute joint.
• Moving the camera invalidates the extrinsics: the homography only holds for the calibrated pose; intrinsics survive.
• Measure pulses per rev per axis: J6 came out at 3200 instead of the designed 1600.
• Do not treat it as a product. The README states Status: Active Development and warns that bugs may exist; use is at your own risk.

📊 Current project status (per the authors)

⚖️ License and usage notes

• License: released under Apache-2.0 (see the LICENSE file in the repository root). Commercial use and modification are allowed, provided you keep the copyright and license notices and state your changes.
• Third-party code: Drivers/ (ST HAL / CMSIS, with its own LICENSE.txt), Middlewares/ and USB_DEVICE/ belong to STMicroelectronics and carry separate (partly BSD-3-Clause) terms — do not delete those license files when redistributing.
• Our role: this page mirrors the files and adds an independent write-up. We are not the authors and we do not modify file contents. Where anything differs, the official repository wins.
• Safety: this machine carries real mass and torque. Limit joint speed and workspace while debugging, nudge small angles before running full sequences, and keep people and fragile objects out of the envelope.

🔗 Official sources

• GitHub · 6-dof-arm-neuralnexusMain repository: full README, reports, schematics, Gerber, firmware, MATLAB and vision scripts
• GitHub · NeuralNexusArm_CodeBase (firmware)Standalone code base for the STM32H743 firmware referenced by the README
• Mirrored · README.mdThe full 37 KB official document (motor selection, gearing, simulation, hardware, software architecture, quick start)
• Mirrored · firmware build and protocol notesPin map, pulses per rev, the three USB CDC requirements, serial protocol
• Mirrored · MATLAB command cheat sheetThe full command sequence from session setup to the two lock demos

❓ FAQ

✅ Next steps

Suggested order: read docs/Neural_Nexus_Final_Report.pdf for the big picture → run the simulation and IK in MATLAB using ik-matlab/GUIDE.txt → flash the firmware and try relative moves over serial → only then touch vision calibration. Change one layer at a time and faults stay easy to localise.