Delta Robot Build: Parallel Arm Mechanism with Servos

A delta robot build parallel arm servo mechanism project is one of the most visually striking and technically interesting robotics challenges you can undertake at home. Delta robots — the triangular pick-and-place machines you see in chocolate factories and pharmaceutical lines — use three independently actuated arms connected to a single end-effector platform. Because all three motors are fixed to the top frame, the moving mass is minimal, allowing extremely fast and precise motion. This guide covers everything from the mechanical concept to Arduino inverse kinematics code.

How Delta Robot Kinematics Work

Unlike a serial arm robot (where joints are chained sequentially), a delta robot uses a parallel kinematic mechanism. Three motors — evenly spaced 120° apart on the fixed base — each drive an upper arm. Each upper arm connects via a pair of parallel rods (the forearms) to a common moving platform. The platform can only translate in X, Y, and Z; it cannot rotate. This constraint is the delta’s superpower: all rotational degrees of freedom are eliminated, so the end-effector stays level regardless of arm angle.

To move the platform to a target (x, y, z) coordinate, you solve the inverse kinematics problem: calculate the angle each motor arm must reach so that all three forearm pairs simultaneously position the platform at the target. This maths involves solving three sphere-intersection equations — one per arm — and while it looks intimidating, it reduces to a clean closed-form formula for the symmetric delta geometry.

For a DIY servo-driven delta, the key geometric parameters are:

• f — radius of the fixed base triangle (motor pivot to centre)
• e — radius of the moving platform triangle
• rf — upper arm length
• re — forearm length (parallel rod length)

A typical small desktop delta uses f = 90 mm, e = 30 mm, rf = 80 mm, re = 160 mm. These values give a working volume of roughly ±60 mm in X/Y and 60 mm in Z depth.

Hardware Overview and Bill of Materials

You can build a functional delta robot for under ₹3,000 with 3D-printed parts, off-the-shelf servos, and an Arduino. Here is the complete BOM:

Servo SG90 9g 180 Degree

Compact 9g servo with 180-degree rotation — ideal for lightweight desktop delta robots with short upper arms under 80 mm.

View on Zbotic

3D Printing the Frame and Arms

STL files for delta robots abound on Printables and Thingiverse. When printing your own, or modifying an existing design, keep these principles in mind:

• Base plate: Print in PETG at 40% infill, 3 perimeters. The base must not flex under servo torque. Add an M5 nut insert at each servo mount point for metal-to-plastic fastening.
• Upper arms: Print in PLA at 4 mm walls, 0% infill (hollow box cross-section is stiffer than honeycomb infill at the same weight). Orient so layer lines run along the arm length to resist bending.
• Forearm rods: Carbon fibre rods (4 mm OD) with 3D-printed end connectors and M3 ball linkages are far stiffer and lighter than fully printed rods. This single upgrade dramatically improves repeatability.
• Moving platform: Keep it small and light. A 60 mm equilateral triangle with three ball-joint sockets is all you need. Print in PETG.

After printing, dry-fit all joints before final assembly. Ball joints should be snug — about 0.3 mm clearance. Use a 4 mm drill bit to clean pivot holes to the correct diameter if your printer’s dimensional accuracy is ±0.3 mm.

Choosing the Right Servos

Servo selection is the single most important hardware decision for a delta robot. Three key parameters:

• Torque: Each servo must support the weight of one upper arm plus one-third of the platform/payload weight at full extension. For a 30g arm and 50g payload, 1.5 kg-cm of torque at 5V is the minimum. SG90 provides 1.8 kg-cm and is acceptable for lightweight builds. MG996R provides 9.4 kg-cm and handles heavier arms.
• Precision: Digital servos have much better position holding and less deadband than analogue. For a delta that needs repeatable pick-and-place, digital is preferred.
• Speed: A faster servo (0.12 s/60° vs 0.20 s/60°) allows higher trajectory speeds. Competition pick-and-place deltas use sub-0.10 s/60° servos.

TowerPro SG90 180° Rotation Servo Motor

Original TowerPro SG90 servo — reliable, lightweight and widely used in delta robot builds worldwide. Ideal for arms under 100 mm.

View on Zbotic

Servo Mount Holder Bracket for SG90/MG90 (Pack of 2)

Aluminium servo mount brackets that securely attach SG90/MG90 servos to a flat surface — great for mounting to a delta robot base plate.

View on Zbotic

Step-by-Step Assembly

1. Mount servos to base: Secure all three servos using the servo bracket and M3 bolts. Servos must be exactly 120° apart. Use a printed jig or protractor to verify angular position before tightening.
2. Centre servos: Before attaching arms, centre all three servos by sending a 90° command (1500 µs pulse). Attach upper arms at exactly horizontal (90°) position using the servo horn.
3. Attach upper arms: Screw the printed upper arm to the servo horn with the horn’s centre screw plus one offset screw for anti-rotation. The arm must be rigid relative to the horn.
4. Attach forearms to upper arms: Connect the first ball-end of each forearm pair to the printed pivot at the end of the upper arm. The two rods in each pair must be parallel — this is critical for platform orientation.
5. Attach forearms to platform: Connect the second ball-end of each forearm pair to the three sockets on the moving platform. The platform should hang freely at the neutral position when all servos are centred.
6. Verify geometry: Move the platform slowly by hand. It should translate smoothly without binding. Any binding means a forearm pair is not truly parallel — adjust the ball-end length on one rod until the pair is equal.

Inverse Kinematics Arduino Code

The inverse kinematics formula for a symmetric delta converts a target (x, y, z) to three servo angles. Below is a simplified implementation. Full derivation is in the original work by Trossen Robotics and Paul Deol.

// Delta Robot Inverse Kinematics
// Zbotic.in — geometry in mm

#include <Servo.h>
Servo servo1, servo2, servo3;

// Geometry constants (mm)
const float f  = 90.0;  // base triangle circumradius
const float e  = 30.0;  // platform triangle circumradius
const float rf = 80.0;  // upper arm length
const float re = 160.0; // forearm length
const float sqrt3 = 1.732050808f;
const float pi    = 3.14159265f;
const float sin120 = sqrt3 / 2.0f;
const float cos120 = -0.5f;
const float tan60  = sqrt3;
const float tan30  = 1.0f / sqrt3;

// Solve for one arm angle given target z offset
int delta_calcAngleYZ(float x0, float y0, float z0, float &theta) {
  float y1 = -0.5f * tan30 * f;
  y0 -= 0.5f * tan30 * e;
  float a = (x0*x0 + y0*y0 + z0*z0 + rf*rf - re*re - y1*y1) / (2.0f * z0);
  float b = (y1 - y0) / z0;
  float d = -(a + b*y1)*(a + b*y1) + rf*(b*b*rf + rf);
  if (d < 0) return -1; // non-reachable
  float yj = (y1 - a*b - sqrt(d)) / (b*b + 1);
  float zj = a + b * yj;
  theta = atan2(-zj, y1 - yj) * 180.0f / pi + 90.0f; // degrees
  return 0;
}

bool calcInverseKinematics(float x0, float y0, float z0,
                            float &t1, float &t2, float &t3) {
  if (delta_calcAngleYZ(x0, y0, z0, t1) != 0) return false;
  if (delta_calcAngleYZ(x0*cos120 + y0*sin120, y0*cos120 - x0*sin120, z0, t2) != 0) return false;
  if (delta_calcAngleYZ(x0*cos120 - y0*sin120, y0*cos120 + x0*sin120, z0, t3) != 0) return false;
  return true;
}

void moveTo(float x, float y, float z) {
  float t1, t2, t3;
  if (calcInverseKinematics(x, y, z, t1, t2, t3)) {
    servo1.write((int)t1);
    servo2.write((int)t2);
    servo3.write((int)t3);
  }
}

void setup() {
  servo1.attach(9); servo2.attach(10); servo3.attach(11);
  moveTo(0, 0, -130); // centre home position
  delay(1000);
}

void loop() {
  // Draw a 40mm radius circle in XY plane at z=-130
  for (int deg = 0; deg < 360; deg += 5) {
    float x = 40.0f * cos(deg * pi / 180.0f);
    float y = 40.0f * sin(deg * pi / 180.0f);
    moveTo(x, y, -130);
    delay(30);
  }
}

Calibration and Testing

After upload, check that the platform homes to the correct position (directly below the centre of the base triangle, at a known Z depth). If it deflects to one side, one servo is not centred or one arm length is different. Correct by adjusting the servo’s physical zero position using a servo tester before attaching the arm.

Run the circle trajectory code. The end-effector should trace a smooth, level horizontal circle. Any wobble in the Z axis indicates parallel rod pairs that are not equal in length. Adjust the ball-end linkage on the shorter rod (turning the clevis adjusts length) until Z wobble is eliminated.

Finally, test the workspace limits. Move the platform to extreme X, Y, and Z values and watch for servo stalling or joints binding. If a servo stalls, reduce the workspace radius in your trajectory code — do not run servos against mechanical stops continuously.

Frequently Asked Questions

Can I build a delta robot without a 3D printer?

Yes. Laser-cut acrylic or hand-drilled aluminium sheet can replace 3D-printed parts. The critical tolerances are the arm pivot spacing (must be symmetric) and forearm lengths (must be equal in each pair). With careful hand-measurement and filing, acceptable accuracy is achievable without printing.

What payload can a servo-driven delta robot carry?

An SG90-driven desktop delta typically handles 30–50g payloads. A MG996R-based delta can manage 100–200g depending on arm geometry. For heavier payloads, replace servos with stepper motors and ballscrew-driven linear actuators — this is the architecture of industrial delta robots.

How precise is a DIY delta robot?

With printed parts and hobby servos, expect ±1–2 mm repeatability. This is sufficient for pick-and-place of objects 10 mm or larger. Sub-millimetre repeatability requires metal arms, high-quality ball joints, and encoder-based servo feedback.

Can I add a vacuum gripper to pick small objects?

Yes. Mount a miniature vacuum pump (5V, 3.5W) and a solenoid valve on the stationary base. Route the tubing down through the forearm assembly to a small suction cup on the platform. Control the valve with a separate Arduino digital pin.

Is it possible to run a delta robot with stepper motors instead of servos?

Absolutely. NEMA17 steppers with A4988 drivers give much better repeatability and can be controlled with a 3D printer motherboard running Marlin firmware (delta kinematics are built in). This is the basis of most desktop delta 3D printers, which are functionally identical in kinematic structure.

Start building your delta robot today! Shop servos, servo brackets, stepper motors, and robot arm kits at Zbotic.in – Robotics & DIY. Expert support and fast delivery across India.