This is our gantry.

Mechanical & structure

1. 2020 aluminum extrusion frame and T-slot hardware.
2. 3D printed parts for end-effector, mounts, and cable guides.
3. Custom end-effector components for needle/forceps grasping.

Actuation & motion

1. Stepper/servo motors (NEMA 17 recommended for gantry, precise closed-loop steppers for end-effector).
2. Stepper drivers (TMC2209 or similar).
3. Lead screws / linear rails / timing belts depending on design.

Electronics & control

1. Main embedded controller: Jetson Orin Nano or Jetson Nano/Orin dev kit for deployment.
2. Microcontroller for low-level stepper control (Arduino Mega or STM32).
3. Power supply: Mean Well 24 V PSU and buck converter for logic rails.
4. Limit switches, E-stop button, manual joystick.

Sensing

1. High resolution overhead USB camera (Arducam or DFRobot IMX179 recommended).
2. Close-up optics / USB microscope lens for fine needle tip tracking.
3. Inline micro load cell + HX711 amplifier for suture tension.
4. Pressure sensor and syringe pump for leak testing.

Misc

1. Micro surgical instruments for fixture work (needle holder, micro forceps) and synthetic vessel phantom tubing.
2. Sutures (scaled analogues for testing if real 10–0 is impractical).
3. Wiring, connectors, mounting hardware

1. Frame and workspace

1. Use 2020 aluminum T-slot extrusion for a stiff base. Keep the gantry low and rigid.
2. Design a small rectangular workspace sized to hold vessel phantom clamps within a 50–150 mm radius from the needle origin. Minimizing lever arms reduces compliance.

2. Gantry & coarse motion

1. Implement an XY gantry for coarse positioning using lead screws or belts. Lead screws give better repeatability; belts are faster but less precise.
2. Use linear rails for guides to reduce side loads and wobble.

3. End-effector & fine orientation

1. Use a 6-DOF wrist (miniature) or a custom gimbal + micro-rotation stage to control needle approach angle.
2. Design the needle grasper to hold a micro needle securely without crushing. Use a small micro-needle holder geometry with repeatable seating. Include a regrasp mechanism if necessary for stitch sequences.
3. Provide a suture management guide so sutures don’t tangle or change tension unexpectedly.

4. Reducing backlash and compliance

1. Backlash is a major failure cause. Options:
2. Use closed-loop steppers with encoders.
3. Add harmonic or cycloidal gearing for the end-effector to eliminate play.
4. Preload lead screws or use anti-backlash nuts.
5. Use stiff, short links and minimize long unsupported sections.

5. Fixtures and phantom mounting

1. Build repeatable jigs that clamp the synthetic vessel in a known orientation and tension. Use a fixture that allows small translational adjustment but locks solidly when clamped.
2. Design a “vessel cradle” that mimics tissue bed geometry; keep the vessel surface level and in the camera’s ROI.

6. Assembly checklist

1. Mount frame and gantry; check orthogonality with a square.
2. Mount end-effector and verify mechanical range of motion covers entire phantom area.
3. Install limit switches at travel ends and test.
4. Wire motors to drivers with common ground. Secure cables to avoid snagging.

1. Power system

1. Primary motor supply: 24 V DC PSU. Fuse at source; size fuse according to motor stall currents.
2. Logic rail: 5 V buck converter with adequate current for microcontrollers, sensors, and cameras. Separate grounds routed to a single star ground point.

2. Motor drivers and controllers

1. Use TMC2209 or similar driver modules for steppers to get quiet operation and micro-stepping. For best control of micro-motions, prefer closed-loop stepper modules with integrated encoders.
2. Low-level motor commands may be generated by a microcontroller running motion planner firmware (e.g., custom Arduino / Marlin-style planner) while higher-level commands come from the Jetson via serial/ROS.

3. Sensor wiring

1. Camera to Jetson via USB 3.0 cable; use short, shielded cables.
2. Load cell to HX711 to microcontroller; route analog wiring away from high-current motor lines.
3. Shield and twist sensor wires to reduce electrical noise. Add ferrite beads if required.

4. Safety and interlocks

1. E-stop in series with motor power enable lines — pressing E-stop should cut motor driver enable signals and put system in safe state.
2. Limit switches wired to interrupt or HALFWAY stop in low-level firmware and also monitored in high-level control.
3. Manual joystick override should bypass autonomous motion; implement a “manual mode” where manual inputs drive motion directly.

1. Camera selection and optics

1. Use a camera with at least 2 MP resolution and low latency (IMX179, IMX290, or similar). I used two 64 megapixel Arducams, but you can use other Jetson Nano compatible cameras. For very small features, using micro cameras is quite important
2. Ring light or coaxial LED lighting reduces shadows. Using diffusers can help with training, but it all matters on your training setup, gpu, etc.

2. Calibration

1. Perform standard camera intrinsics calibration (chessboard pattern) to compute focal length and distortion coefficients.
2. Calibrate pixel→mm conversion at the working distance using a micro ruler or calibration grid placed at the vessel plane.

3. Image pipeline basics

1. Capture frames at a consistent frame rate (≥30 fps recommended). Use timestamping at capture to synchronize with motor commands.
2. Preprocess: crop to ROI, convert to grayscale, apply CLAHE if necessary, and use Gaussian blur to reduce noise.
3. Needle tip & vessel detection: use either classical computer vision (edge detection + Hough transforms + template matching) or a light-weight CNN trained to output needle and vessel masks. For speed, prefer small networks (MobileNet-based) or carefully tuned CV.

For measuring suture tension, I used a small inline load cell paired with an HX711 amplifier. I mounted it directly in the suture path so that any pulling force would go through the sensor. This made it easy to capture real-time tension data during each stitch.

Before running any tests, I calibrated the load cell using small known weights and recorded the offset. I also re-zeroed it before every trial because even tiny drifts can mess up readings at this scale.

To clean up the signal, I added basic averaging in software. Without it, the readings were too noisy, especially when the motors were moving. If you’re building your own version, you can also:

1. Use better shielding on wires
2. Add a hardware filter
3. Or upgrade to a higher precision amplifier

For control, I implemented a simple closed-loop system where the robot tries to stay within a safe tension range. If the force goes too high, it immediately stops pulling to avoid damaging the vessel.

I split the system into a few main parts so it wouldn’t become a mess:

1. Low-level control

This runs on a microcontroller (I used an Arduino). It handles:

1. Stepper motor control
2. Limit switches
3. Basic safety

2. High-level control

This runs on the main computer (I used a Jetson). It handles:

1. Vision processing
2. Running the AI model
3. Sending movement commands

3. Communication

I connected everything using serial communication. You could also use ROS if you want something more scalable, but for me, serial was simpler and worked fine.

This was one of the most important parts of the project.

I trained the system in simulation first because it’s way faster and safer than testing directly on hardware.

Environment

I used NVIDIA Isaac Sim to build a virtual version of the setup. This included:

1. A simulated vessel
2. A needle
3. Basic physics for interaction

If you don’t want to use Isaac Sim, you could use another physics simulator, but it needs to support some level of soft-body interaction.

Other platforms include Genesis, or Unity.

Originally, I tried using a school borrowed computer with an RTX 3060, but eventually had to rent an online GPU cluster with a RTX 5090, costing only around $10-15 using Tensordock.

State (what the model sees)

1. Camera image (or processed features)
2. Needle position
3. Sometimes force data

Actions (what the model does)

1. Move the needle (x, y, z, rotation)
2. Open/close gripper
3. Pull suture

Reward (how it learns)

I rewarded the model for:

1. Hitting the correct entry point
2. Completing a stitch
3. Keeping spacing consistent

I penalized it for:

1. Missing the target
2. Applying too much force
3. Damaging the vessel

I started simple:

1. Static vessel, no randomness
2. Then added variation (lighting, position, stiffness)
3. Slowly increased difficulty

This helped the model actually learn instead of failing constantly at the start.

To make it work in real life, I used domain randomization: this basically prevents overfitting and allows the system to work in many different conditions.

1. Changed lighting
2. Added noise
3. Slightly varied physics

This makes the model more robust when moved to hardware.

Once the model worked well in simulation, I moved it to the NVIDIA Jetson Orin Nano.

To make it run fast enough:

1. I optimized the model (TensorRT helps a lot)
2. Reduced image size slightly
3. Made sure inference stayed under ~100 ms

Before running anything real, I tested with:

1. No needle movement (just predictions)
2. Very slow movements

This helped avoid breaking anything early.

PS. please make sure your power supply is connected only to the CNC board on the Arduino, not directly to power and computer or microcontroller

Unfortunately, I learned this the hard way :(

Go ahead and calibrate each component to its gantry, based on your dimensions.

Every trial, I logged:

1. Target position
2. Actual needle position
3. Tension over time
4. Whether the stitch succeeded
5. Failure reason

I stored everything in CSV files so I could analyze it later.

If you’re building this, logging is one of the most important things for improving the system throughout.

Each trial followed the same process:

1. Mount the vessel phantom
2. Reset sensors and zero force
3. Run the stitching sequence
4. Record everything

After that, I tested the quality of the anastomosis by:

1. Checking spacing
2. Looking for damage
3. (Optional) running a leak test with water pressure

These were the main ones I used:

1. Accuracy (MRE) → how close each stitch was
2. Spacing consistency → how evenly stitches were placed
3. Tension control → whether force stayed in safe range
4. Success rate → full procedure completed correctly
5. Latency → how fast the system reacts

Simulation results were very high (97%), but hardware dropped (72%) mainly due to mechanical issues.

Currently, I built the entire system using mg946r servos and sg90 servos for the gripper, but these have significant levels of backlash causing issues later.

Cad Files Attached: