Robotic Arm DIY Guide: Servo-Based Manipulator

Building a robotic arm DIY project is one of the most rewarding challenges in hobby robotics. A servo-based manipulator teaches you mechanics, electronics, and programming all at once — and the result is a physical machine that can pick up objects, draw patterns, or mimic your hand movements. This guide walks you through every step from choosing servos to adding a gripper and Bluetooth control.

Types of Robotic Arms: DOF Explained

DOF stands for Degrees of Freedom — the number of independent joints that can move. More DOF means more flexibility but also more complexity:

• 3-DOF: Base rotation + shoulder + elbow. Simplest arm. Can reach positions in a plane. Good for beginners.
• 4-DOF: Adds wrist pitch. Can approach objects from different angles. The most common hobbyist arm configuration.
• 5-DOF: Adds wrist rotation. Much more capable, can orient the gripper in more positions. ACEBOTT’s robot arm kit is 5-DOF.
• 6-DOF: Industrial standard — fully flexible like a human arm and wrist. Complex to program but capable of any orientation in its workspace.

For a first DIY build, a 4-DOF arm with a gripper is ideal. It is complex enough to be a genuine learning challenge while remaining buildable in a weekend.

Servo Selection: SG90, MG996R, and Bus Servos

The servo is the most important component of any robotic arm. Choosing the right one for each joint makes the difference between a floppy, inaccurate arm and a precise, responsive manipulator.

SG90 (Micro Servo)

Weight: 9g. Torque: 1.8 kg.cm. Speed: 0.1 sec/60°. Cost: ₹150–250 each. The SG90 is suitable for small, lightweight arms made from 3D-printed or thin acrylic parts carrying payloads under 100g. It is fine for wrist and finger/gripper joints in a desktop arm but too weak for shoulder and elbow joints where gravity creates high torque loads.

MG996R (Standard Metal Gear Servo)

Weight: 55g. Torque: 9.4 kg.cm (stall). Metal gears make it significantly more durable and accurate than the SG90 under load. Use MG996R for the base, shoulder, and elbow joints — any joint that supports the weight of the arm segments above it. At ₹400–700 each, it is a worthwhile investment for a reliable arm.

Bus Servos (Waveshare / Herkulex)

Bus servos communicate digitally via a serial bus (TTL UART). Each servo has a unique ID and can be addressed individually on a single 3-wire bus. Advantages:

• Position feedback — you can read the actual current angle
• Built-in PID control and configurable speed/torque limits
• Daisy-chain wiring: only 3 wires for the entire arm regardless of DOF count
• Higher torque options available (20 kg.cm, 45 kg.cm)

Parts List for a 4-DOF Servo Arm

• 4x MG996R servo (base, shoulder, elbow, wrist pitch)
• 1x SG90 or MG90S (gripper)
• 1x Arduino Uno or Mega (Mega recommended for 6+ servos)
• Acrylic or 3D-printed brackets (arm segments, servo mounts)
• M3 screws, nuts, spacers (assorted hardware kit)
• 5V 3A external power supply or 2x 18650 in parallel (separate from Arduino power)
• 10kΩ potentiometers x4 (for manual control, one per joint)
• HC-05 Bluetooth module (for app control)
• Breadboard and jumper wires
• Capacitors: 100µF across servo power rails to handle current spikes

Assembly: Brackets and Frame

For a beginner build, laser-cut acrylic brackets are the most accessible option. Many hardware shops in India can cut acrylic from a DXF file, and templates are freely available online. 3D-printed brackets work well if you have access to an FDM printer — PLA at 40–60% infill is strong enough for light arms.

Assembly order:

1. Base: Mount the base servo in a fixed plate. The servo horn connects to the rotating base plate. This is your yaw axis.
2. Shoulder: Attach the first arm segment to the base plate with the shoulder servo at the pivot. A second servo on the opposite side (mirrored) helps distribute load on long arms.
3. Elbow: The second arm segment connects at the elbow joint. Keep arm segments light — use hollow acrylic or thin-wall 3D prints.
4. Wrist: Mount the wrist servo at the end of the second segment. Attach the gripper mechanism to the wrist horn.

Critical tip: servo horns must be secured with the self-tapping screw that comes with each servo. A loose horn causes backlash and inaccuracy throughout the arm.

Wiring Servos to Arduino

Each servo has three wires: Brown/Black (GND), Red (VCC 5V), Orange/Yellow (Signal). Key rules:

• Never power servos directly from the Arduino’s 5V pin. Multiple servos draw 1–2A each under load. The Arduino’s onboard regulator provides only 500mA and will be damaged. Use an external 5V 3A+ power supply connected directly to servo VCC and GND.
• Connect the external supply’s GND to Arduino GND to create a common reference.
• Signal wires connect to Arduino PWM-capable pins (9, 10, 11 on Uno; more available on Mega).
• Add a 100µF capacitor between VCC and GND at the servo power bus to absorb current spikes.

Potentiometer Manual Control Code

This sketch reads four potentiometers and maps their positions to four servo angles in real-time — a simple and intuitive way to manually position the arm:

#include <Servo.h>

Servo baseServo, shoulderServo, elbowServo, wristServo;

// Potentiometer pins
const int POT_BASE     = A0;
const int POT_SHOULDER = A1;
const int POT_ELBOW    = A2;
const int POT_WRIST    = A3;

// Servo angle limits (adjust for your arm geometry)
const int BASE_MIN = 0,    BASE_MAX = 180;
const int SHD_MIN  = 30,   SHD_MAX  = 150;
const int ELB_MIN  = 0,    ELB_MAX  = 170;
const int WRT_MIN  = 0,    WRT_MAX  = 180;

void setup() {
  baseServo.attach(9);
  shoulderServo.attach(10);
  elbowServo.attach(11);
  wristServo.attach(6);
}

void loop() {
  int baseAngle     = map(analogRead(POT_BASE),     0, 1023, BASE_MIN, BASE_MAX);
  int shoulderAngle = map(analogRead(POT_SHOULDER), 0, 1023, SHD_MIN,  SHD_MAX);
  int elbowAngle    = map(analogRead(POT_ELBOW),    0, 1023, ELB_MIN,  ELB_MAX);
  int wristAngle    = map(analogRead(POT_WRIST),    0, 1023, WRT_MIN,  WRT_MAX);

  baseServo.write(baseAngle);
  shoulderServo.write(shoulderAngle);
  elbowServo.write(elbowAngle);
  wristServo.write(wristAngle);

  delay(15); // Give servos time to move
}

Serial Command Control

For more precise control, send angle commands over Serial (or Bluetooth). This lets you program sequences of movements:

// Send commands like: B90 S60 E120 W45 G30
// B=Base, S=Shoulder, E=Elbow, W=Wrist, G=Gripper

void loop() {
  if (Serial.available() > 0) {
    char joint = Serial.read();
    int angle = Serial.parseInt();
    angle = constrain(angle, 0, 180);
    switch(joint) {
      case 'B': baseServo.write(angle);     break;
      case 'S': shoulderServo.write(angle); break;
      case 'E': elbowServo.write(angle);    break;
      case 'W': wristServo.write(angle);    break;
      case 'G': gripperServo.write(angle);  break;
    }
  }
}

Adding a Gripper

The simplest gripper uses one SG90 servo and two 3D-printed or acrylic finger links connected via a push rod mechanism. As the servo rotates from 0° to 60°, the fingers close. The gripper should:

• Close fully around small objects (pencil, small cube) at around 30–45° servo travel
• Generate enough pinch force without stripping the servo gears (add a rubber pad to finger tips for grip)
• Return smoothly to open position at 0° without backlash

Rubber tips on the gripper fingers (cut from a rubber band or foam pad) dramatically improve grip on smooth surfaces compared to bare plastic.

Bluetooth App Control

Wire an HC-05 module to the Arduino (TX→pin 10, RX→pin 11 via voltage divider). Use a free Android app like ‘Serial Bluetooth Terminal’ or build one in MIT App Inventor. Send the same joint commands (B90, S60, etc.) over Bluetooth. The arm responds in real-time.

For smooth trajectories, interpolate between current and target angle in steps of 2–5 degrees with a small delay rather than jumping instantly. This protects the mechanical joints from shock loads.

Accuracy Improvements

Common sources of inaccuracy in servo arms and how to fix them:

• Backlash in gears: Use metal gear servos (MG996R) or bus servos with encoders. Avoid cheap plastic-gear clones.
• Loose servo horns: Apply thread-lock compound (Loctite) on the centre screw or use a friction fit horn with a circlip.
• Power fluctuations: Add bulk capacitors (470µF–1000µF) at the power input. Servo current spikes cause voltage dips that make other servos twitch.
• Gravity sag on long segments: Keep arm segments as light as possible. Add counterweights at the base if necessary.
• PWM jitter: Use a PCA9685 I2C servo controller board instead of Arduino’s software PWM for much more stable servo positioning (16 channels, hardware PWM generator).

Frequently Asked Questions

Q: How many servos do I need for a basic robotic arm?

A functional 4-DOF arm with a gripper needs 5 servos: base (rotation), shoulder, elbow, wrist pitch, and one for the gripper. This is a good starting configuration. You can add wrist roll as a 6th servo once you are comfortable with the basics.

Q: Can I power 5 servos from an Arduino Uno?

No. You must use a separate 5V power supply rated at least 3A (5A is better). Connect the external supply GND to Arduino GND, but supply 5V directly to the servo bus, not through the Arduino’s 5V pin. Powering multiple servos from the Arduino will damage the board’s regulator.

Q: What is inverse kinematics and do I need it?

Inverse kinematics (IK) calculates what joint angles are needed to place the gripper at a specific (x,y,z) point in space. It requires trigonometry (sin/cos/atan2). For basic projects, you do not need IK — just set each joint angle manually or via potentiometers. IK becomes useful when you want to program the arm to move in straight lines in Cartesian space or when building an automated pick-and-place system.

Q: What is the difference between a bus servo and a standard PWM servo?

Standard PWM servos use a single-wire analog signal (50Hz, 1–2ms pulse). Bus servos use a digital serial protocol where each servo has an ID and can be individually addressed on a shared 3-wire bus. Bus servos provide position feedback, velocity control, torque limiting, and much higher accuracy. They cost more but are worth it for serious arm builds.

Q: What practical applications can a DIY robotic arm do?

With a good 4–5 DOF arm you can do: pick-and-place sorting of small objects, holding a pen for drawing/writing, operating small switches and buttons, dispensing liquids with a syringe attachment, and demonstrating industrial automation concepts. With computer vision (camera + Raspberry Pi), you can add colour-based object detection and sorting.