Build a 4-DOF Robot Arm: PCA9685, Servos, and Kinematics

A robot arm is the first project where a robot stops moving around and starts doing something to the world. A line follower follows; an obstacle-avoider dodges; an arm reaches, positions, and grips. That shift—from driving to manipulation—brings in the one idea every manipulator is built on: kinematics, the geometry that connects the angles you can command to the point in space you actually want.

This build path treats the arm as exactly that: a lesson in kinematics you can hold. You start by understanding how a two-link arm turns joint angles into a tool position and back again, gather the parts a servo arm needs and learn what each one does, then—before spending anything or stripping a gear—explore the reach, the two elbow solutions, and the unreachable poses in the browser simulator. Only then do you wire the real arm, calibrate its servos by hand, and run the inverse kinematics on hardware.

Follow the tech tree below top to bottom. Each node opens once its prerequisites are done, and your progress is saved on this device, so you can build the arm over a weekend without losing your place.

Bill of materials

Total: roughly $40–60.

Two purchases are worth thinking about rather than defaulting on. A metal-gear MG90S at the shoulder costs a dollar more and is the joint carrying every other joint’s weight — nylon gears there strip under sustained load, not under impact. And a supply sized for stall, because an arm’s distinctive failure is that when it collides with its own frame or grips something solid, every servo stalls at once.

Measure your arm before you write any code

Inverse kinematics is arithmetic on link lengths. These four numbers are the entire input, and getting them from a product listing rather than a ruler is the most common reason an arm reaches confidently to the wrong place.

That last row is doing more work than it looks. “The gripper’s actual grip point” moves as the jaws close, and sizing the gripper itself is a separate problem from positioning it — with its own walls, its own arithmetic and its own failure modes. If your arm reaches the part and then drops it or crushes it, the answer is not in this page: start at the gripper simulator. | h | Table surface | Shoulder joint axis | 50–70 mm | | d | Base rotation axis | Shoulder axis, horizontally | 0–15 mm |

Measure between joint axes, not bracket edges. The axis is the centre of the servo’s output spline, often 5–10 mm inside the visible bracket. On a 95 mm link a 10 mm error is over 10%, and it produces an arm that is systematically short in a way no gain corrects.

Those two lengths give you the workspace immediately:

maximum reach = L1 + L2          e.g. 100 + 90 = 190 mm
minimum reach = |L1 - L2|        e.g. |100 - 90| = 10 mm

The workspace is an annulus, not a disc. There is a hole in the middle the arm physically cannot reach, and a target near the base coming back “unreachable” is correct behaviour rather than a bug.

Build it in milestones

The assembly order here contains one step that is nearly impossible to undo, and it is step 2.

Milestone 2 cannot be recovered from later. A servo horn is splined — around 20 teeth — so it fits only in discrete positions roughly 18° apart. Assemble first and calibrate second, and you may find a joint whose usable range is offset by 40° with no mechanical way to fix it. Power each servo, command 90°, then press the horn on.

Move it gently, always

A servo commanded to a new angle goes there at full speed. On an arm that means a violent movement, a current spike across all four servos, and a mechanical shock through nylon gears with the arm’s own leverage multiplying it.

// Interpolate every joint together, so the tool takes a sensible path and
// no single servo carries the whole transition.
void moveTo(float base, float shoulder, float elbow, int steps, int stepMs) {
  static float cur[3] = {0, 0, 0};
  const float target[3] = {base, shoulder, elbow};

  for (int s = 1; s <= steps; s++) {
    const float t = (float)s / steps;
    for (int j = 0; j < 3; j++) {
      const float a = cur[j] + (target[j] - cur[j]) * t;
      pwm.setPWM(JOINT[j].channel, 0, countsFor(JOINT[j], a));
    }
    delay(stepMs);
  }
  memcpy(cur, target, sizeof(cur));
}

Interpolating all joints together matters as much as the smoothing itself. Moving joints one at a time sends the tool on a strange arc through the workspace — slower, and far more likely to collide with something on the way.

What good looks like

The gap between the two repeatability rows is the backlash, and it is the single largest error source on a hobby arm. Four degrees of play at the shoulder over a 190 mm reach is more than 13 mm at the gripper. The practical answer is not better maths — it is to always approach a target from the same direction, which removes the sign change entirely and turns a ±13 mm error into a repeatable offset you can calibrate out.

Troubleshooting

Where to take it next

Add a straight-line move. Interpolating in joint space, as the code above does, makes the tool follow a curve. Interpolating in Cartesian space — computing IK at every step along a straight line — makes it travel straight, which is what any real pick-and-place needs. It is a small change and it is where singularities stop being theoretical: a straight path through near-full extension demands enormous joint velocities.

Add a camera and close the loop. Everything here is open loop: the arm goes where it is told and never checks. A camera reading an ArUco marker on the object lets the arm correct for the error backlash and sag leave behind — which is how a cheap arm becomes accurate.

Step up the hardware once you hit the ceiling. Aluminium links remove most of the flex, MG90S servos remove most of the backlash, and a 6-DOF arm adds a wrist so the tool’s approach angle becomes yours to choose. None of it changes the maths: the two-link solver you wrote here is the same one a better arm uses, which is exactly why the cheap frame was worth building on first.