Stage 05 · Lesson 14/15

Robotics Fundamentals · Lesson 14

Bridge to the 6DOF Arm

Est. 50–65 min

Why

Why this lesson is your pre-flight check

You have learnt the fundamentals one at a time. This chapter connects them to the 6DOF arm course on this site — the build where everything becomes real metal, real servos and real current. The course’s own chapters recommend MG996R-class metal-gear servos for the base and shoulder, an Arduino-class microcontroller with either direct PWM pins or a PCA9685 16-channel PWM driver, and a separate 5–6 V servo supply with a common ground, rated 10 A or more because six loaded servos can momentarily demand 8–10 A. Every one of those choices comes from a Stage 5 lesson.

By the end you will be able to: map each joint of a 6-servo arm to DOF, torque, sensing and limits; tell honestly how many joints position the tool when one servo is the gripper; check your power plan against the course’s supply rule; run a self-check that says GO or REVISIT; rehearse a safe single-servo power-up; and know which course chapter each Stage 5 lesson prepares you for.

A tall beige PUMA 200 robot arm in a workshop with an access cover removed, showing motors and gears inside the upper arm
A Unimate PUMA 200 arm with an access cover removed. Inside: motors, gears and wiring for each joint — the same layers as your servo arm, just in an industrial shell. Your 6DOF build will expose all of this, so you can see every fundamental at work.Photo: Razor Robotics · CC BY 2.0 · Source: Wikimedia Commons · resized, converted to WebP

Concept

Every Stage 5 idea, mapped onto the real arm

Think of moving from driving lessons in an empty ground to driving on a real road. You already know the steering, the clutch and the brakes. On the road, nothing new is invented — but everything happens together, with real consequences. The 6DOF build is that road. This chapter is the last practice lap in the ground.

Stage 5 lessons → 6DOF course chapters

Where each fundamental is used in the build
Stage 5 lessonYou will use it in…What you will do
3 — Joints, links & DOFMechanical Structure, Joints & DOF MappingLabel J1–J6, count pose DOF vs gripper
4 — Configuration spaceInverse Kinematics Intro; First Programmed MotionsChoose elbow solutions; avoid self-collision
5 — Actuators & transmissionsServos & PowerSize the shoulder; pick servo classes per joint
6 — Sensors & proprioceptionCalibration & TestingKnow what the servo pot measures and what it doesn’t
7 — Sense–plan–actFirmware Basics (Servo Control)Structure the control loop and command parsing
8 — FeedbackFirmware Basics; Calibration & TestingUnderstand why servos hold position, and their limits
9 — Workspace & reachWhat is a 6DOF Arm & Safety; Inverse Kinematics IntroMeasure the workspace radius; place targets in the sweet spot
10 — Frames, pose & TCPInverse Kinematics Intro; Calibration & TestingDefine the base frame and TCP; set joint zeros
11 — End effectorsGripper & End EffectorSet gripper open/close angles per object
13 — Safety & limitsWhat is a 6DOF Arm & Safety; Controller Board & WiringSoft limits, power-off rule, e-stop

Mapping a 6-servo arm

A typical 6-servo hobby arm (check your own kit)
JointMotionTypeLoad (worst case)Watch for
J1 baseYaw (turn left/right)RLow torque, high inertiaSmooth slow moves; cable twist
J2 shoulderPitchRHighest holding torque (Lesson 5)Strongest servo; arm sag at full reach
J3 elbowPitchRHigh torqueElbow-up vs elbow-down choice
J4 wrist pitchPitchRMediumKeeps the gripper level or angled
J5 wrist rollRollRLowOrientation of the gripper fingers
J6 gripperOpen/closeEnd-effectorGrip force (Lesson 11)Stall when closed too far

Power: the numbers that decide success

worst-case current ≈ (servos stalled × stall current) + (other servos × moving current)

  • The course gives a rule of thumb: hobby metal-gear servos can exceed 1–2 A each at stall. With two servos stalled at 1.5 A and four moving at about 0.5 A: 2 × 1.5 + 4 × 0.5 = 5.0 A. With 25% headroom that needs 6.25 A — inside a 10 A supply. Use your own servos’ datasheet values.
Two black hobby servo motors with three-wire leads on a white table; one has a round white horn on top, the other shows its splined output shaft
Hobby servos from Stage 4. In the 6DOF build there are six of them, and each one draws more current the harder it works. The supply, wires and ground must be planned for all six at once (Lessons 2 and 5).Photo: Kborer · Public domain · Source: Wikimedia Commons · resized, converted to WebP

The first power-up, step by step

  1. One servo, no horn

    Power a single servo from the 5–6 V supply, common ground, with no horn or link attached. Command 90° with gentle steps.

  2. Then each servo alone

    Repeat for each servo before assembly. Mark its 90° position. Note any that buzz or run hot.

  3. Assemble at the centre

    Fit horns and links with each servo at its centre mark, as the course’s calibration chapter explains.

  4. E-stop and limits first

    Before moving the assembled arm, test the e-stop and load soft limits (Lesson 13).

  5. One joint at a time

    Move each joint slowly through a small range, then a larger one, watching the supply voltage.

Visual

Visualise it: a shoulder–elbow–wrist chain

Move the shoulder, elbow and wrist sliders and read the **end-effector pose**. This is the same chain as J2–J4 of your arm, seen from the side — and a preview of forward kinematics in Stage 8.

Interactive · FK chain visualizer (3R planar educational)

FK transform chain Base→J1…→EE6DOF FK schematic

Simplified 3R planar stand-in for Base→J1→J2→J3→EE. Full 6DOF adds wrist RPY on top of this position chain.

EE x

153.4

EE y

35.8

ᵇTₑ (planar) calculator

0.966-0.2590.000157.02
0.2590.9660.00020.55
0.0000.0001.0000.00
0.0000.0000.0001.000

Code lab

Code lab: readiness self-check, joint map and power check

Fill in SELF_CHECK with honest answers. The script prints your score and a GO / REVISIT verdict (a recommendation, not a lock), maps a six-servo arm onto joint types, and checks a worst-case current estimate against the course’s 10 A supply rule. Run it with python3 readiness_check.py.

readiness_check.py · Python
"""readiness_check.py - are you ready for the 6DOF arm course? (soft recommendation, not a lock)
Edit SELF_CHECK with honest answers, then run."""

SELF_CHECK = {
    "count DOF of a serial arm": True,
    "explain C-space vs workspace": True,
    "size a servo with torque = m*g*d": True,
    "name proprio vs extero sensors": True,
    "write a sense-plan-act loop": True,
    "explain open vs closed loop": False,
    "check reach with the law of cosines": True,
    "define TCP and base frame": True,
    "pick a gripper for a 50 g part": False,
    "list joint limits + keep-out + e-stop": True,
}
LESSON = {"count DOF of a serial arm": 3, "explain C-space vs workspace": 4, "size a servo with torque = m*g*d": 5,
          "name proprio vs extero sensors": 6, "write a sense-plan-act loop": 7, "explain open vs closed loop": 8,
          "check reach with the law of cosines": 9, "define TCP and base frame": 10, "pick a gripper for a 50 g part": 11,
          "list joint limits + keep-out + e-stop": 13}

ARM = ["J1 base yaw", "J2 shoulder pitch", "J3 elbow pitch", "J4 wrist pitch", "J5 wrist roll", "J6 gripper"]

done = sum(SELF_CHECK.values())
print(f"== Self-check: {done}/{len(SELF_CHECK)} ==")
for skill, ok in SELF_CHECK.items():
    print(f"[{'x' if ok else ' '}] {skill:40s} (Lesson {LESSON[skill]})")
gaps = [LESSON[s] for s, ok in SELF_CHECK.items() if not ok]
verdict = "GO - start the 6DOF arm course" if done >= 8 else "REVISIT first"
print(f"\nverdict: {verdict}" + (f"; quick revisit: Lessons {', '.join(map(str, gaps))}" if gaps else ""))

print("\n== Map Stage 5 ideas onto a 6-servo arm ==")
for j in ARM:
    kind = "end effector" if "gripper" in j else "revolute joint, 1 DOF"
    print(f"{j:18s} -> {kind}")
print("note: if J6 is a gripper, the arm positions its tool with 5 joints; check what your kit calls '6DOF'")

print("\n== Power sanity check (course rule: 5-6 V servo supply rated >= 10 A, common ground) ==")
supply_a, servos, worst_stall_a = 10, 6, 1.5    # replace stall current with your servo datasheet value
two_stall = 2 * worst_stall_a + (servos - 2) * 0.5
print(f"two servos stalled + four moving ~ {two_stall:.1f} A vs {supply_a} A supply -> {'OK' if two_stall * 1.25 <= supply_a else 'too small'} with 25% headroom")

Output (run with python3 readiness_check.py)

== Self-check: 8/10 ==
[x] count DOF of a serial arm                (Lesson 3)
[x] explain C-space vs workspace             (Lesson 4)
[x] size a servo with torque = m*g*d         (Lesson 5)
[x] name proprio vs extero sensors           (Lesson 6)
[x] write a sense-plan-act loop              (Lesson 7)
[ ] explain open vs closed loop              (Lesson 8)
[x] check reach with the law of cosines      (Lesson 9)
[x] define TCP and base frame                (Lesson 10)
[ ] pick a gripper for a 50 g part           (Lesson 11)
[x] list joint limits + keep-out + e-stop    (Lesson 13)

verdict: GO - start the 6DOF arm course; quick revisit: Lessons 8, 11

== Map Stage 5 ideas onto a 6-servo arm ==
J1 base yaw        -> revolute joint, 1 DOF
J2 shoulder pitch  -> revolute joint, 1 DOF
J3 elbow pitch     -> revolute joint, 1 DOF
J4 wrist pitch     -> revolute joint, 1 DOF
J5 wrist roll      -> revolute joint, 1 DOF
J6 gripper         -> end effector
note: if J6 is a gripper, the arm positions its tool with 5 joints; check what your kit calls '6DOF'

== Power sanity check (course rule: 5-6 V servo supply rated >= 10 A, common ground) ==
two servos stalled + four moving ~ 5.0 A vs 10 A supply -> OK with 25% headroom

Try it: set a servo’s pulse and load on the virtual bench and watch the current — the same habits you need when six servos share one supply.

Interactive · Motor & Servo Bench

Compare a safe path (PWM → driver → motor, common ground, separate power) vs the dangerous habit of driving a motor from a bare GPIO pin. Simulated only.

DC motor (via driver)

MOTOR

Driver handles current. MCU only sends logic-level PWM. Common ground required.

Servo (pulse width)

Servo needs dedicated 5–6 V power + signal from MCU. Soft limits before multi-joint arms.

Real world

From classic arms to your desk

  • Classic industrial arms (PUMA, KUKA): six joints, encoders, gearboxes, a controller and a guarded cell — the grown-up version of your build.
  • Collaborative arms (UR series): teach pendants, reduced speeds and built-in limits — the safety habits from Lesson 13.
  • Your desk arm: MG996R-class servos at the base and shoulder, a PCA9685 or direct PWM, and a separate supply rated 10 A or more, as the course recommends.

Bench build

Bench build: a single-servo power-up rehearsal

Before the arm arrives (or before you assemble it), rehearse the exact power-up procedure with one servo. You will use slow_servo_steps.ino from Lesson 2 and your Lesson 13 e-stop if you built it.

  1. Prepare

    Clear the desk. Servo unmounted, horn removed. Supply set to 5–6 V and measured. E-stop (if built) in the supply line.

  2. Wire

    Signal → pin 9; servo power from the supply; supply GND → Arduino GND. Check twice that nothing from the servo goes to the Arduino 5 V pin.

  3. Power order

    Plug in the Arduino (USB) first, upload the sketch, then switch on the servo supply.

  4. Centre

    Type 90 in the Serial Monitor. Mark the shaft’s position with a marker — this is your centre mark for assembly.

  5. Sweep

    Type 45, 135, then 20 and 160 (the soft limits). Watch and listen: smooth motion, no buzzing at rest.

  6. Stop test

    Press the e-stop (or unplug the supply) mid-move. The servo must go limp. Restore power: nothing should move until you send a new angle.

  7. Log

    Write supply voltage at rest and moving, and any noises. Repeat for every servo in your kit.

slow_servo_steps.ino (from Lesson 2) · Arduino C++
// slow_servo_steps.ino - move one joint in gentle 1-degree steps between soft limits.
// Servo signal on pin 9. Servo power comes from a SEPARATE 5-6 V supply, grounds joined.
#include <Servo.h>

Servo joint;
const int PIN = 9;
const int SOFT_MIN = 20;      // stay away from the hard end stops
const int SOFT_MAX = 160;
const int STEP_DELAY_MS = 15; // about 66 degrees per second

int angle = 90;

void moveTo(int target) {
  target = constrain(target, SOFT_MIN, SOFT_MAX);
  while (angle != target) {
    angle += (target > angle) ? 1 : -1;
    joint.write(angle);
    delay(STEP_DELAY_MS);
  }
  Serial.print("at ");
  Serial.println(angle);
}

void setup() {
  Serial.begin(9600);
  joint.write(angle);   // set the start position before attach() so it does not jump
  joint.attach(PIN);
  Serial.println("type an angle (20-160) and press Enter");
}

void loop() {
  if (Serial.available()) {
    int target = Serial.parseInt();
    if (target > 0) moveTo(target);
  }
}
A desk with an Arduino Uno connected by USB, a 9 V battery in a clip plugged into the Uno’s barrel jack, a white breadboard and a small black servo connected by jumper wires
A beginner’s one-servo test from Stage 4. Fine for watching one unloaded micro servo; for the 6DOF arm the servos must have their own 5–6 V supply rated for their combined current, with the ground joined to the board.Photo: Hagirkhalifa · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Debugging

Debugging the first days of the build

SymptomLikely causeStage 5 lessonFix
Arm jumps at power-upServos go to a default position13Power one at a time; start angle before attach(); latched start
Board resets when the shoulder movesSupply sag / shared supply2, 5Separate supply ≥ 10 A; capacitor; short thick wires
Shoulder sags at full reachTorque near the servo’s limit5Stronger servo; lighter forearm; keep work closer
Gripper closes 2 cm off targetJoint zeros or TCP wrong10Calibrate centres; measure tool offset
IK says “unreachable” for a close pointOutside the ring or a joint limit9, 4Check r; try the other elbow solution
Gripper servo hot while holdingClosing past the touch point11Per-object closed angle

Think

Think about it

Think

Arjun’s readiness check says 6/10 — REVISIT. He says, “It’s only a recommendation, I’ll start the build anyway.” Meera says, “Then at least revisit the four lessons that matter most for the first week.” Which four would you pick, and why?

Experiment

Try it in the lab: readiness check and a single-servo rehearsal

Thirty to forty minutes: the FK chain visual, the readiness script, the course’s table of contents and — if you have a servo — the rehearsal.

Experiment

Readiness check and a single-servo rehearsal

You will need

  • FK chain visualizer (below, runs in your browser)
  • The 6DOF arm course chapter list
  • Optional: `readiness_check.py`; one servo, Arduino, 5–6 V supply, marker

Steps

  1. In the FK visualizer, set the shoulder, elbow and wrist so the end-effector points straight down. Write the three angles.
  2. Run `readiness_check.py` with honest answers. Write your verdict and gaps.
  3. For each gap, open the matching Stage 5 lesson and re-do its knowledge check.
  4. Run the single-servo rehearsal and mark the centre of each servo you have.
  5. Write your own pre-flight checklist (10 lines max) for the first power-up of the full arm.

Interactive · FK chain visualizer (3R planar educational)

FK transform chain Base→J1…→EE6DOF FK schematic

Simplified 3R planar stand-in for Base→J1→J2→J3→EE. Full 6DOF adds wrist RPY on top of this position chain.

EE x

153.4

EE y

35.8

ᵇTₑ (planar) calculator

0.966-0.2590.000157.02
0.2590.9660.00020.55
0.0000.0001.0000.00
0.0000.0000.0001.000

Every decision in the 6DOF build traces back to a Stage 5 idea. A short checklist and a single-servo rehearsal catch most first-day mistakes before they cost a servo — or a finger.

Knowledge check

Check your understanding

Knowledge check

1. The 6DOF course recommends a servo supply of…

2. If J6 of your arm is the gripper, how many joints position the tool?

3. Which joint usually needs the highest holding torque?

4. Two servos stalled at 1.5 A plus four moving at 0.5 A draw about…

5. Why power-test each servo alone with the horn removed?

6. Which Stage 5 lesson prepares you for the course’s “Gripper & End Effector” chapter?

7. The readiness script’s verdict is…

8. The board resets whenever the shoulder starts moving. Which lessons help most?

9. The course recommends MG996R-class servos for which joints?

Mini assignment

Hands-on assignment

Mini assignment

Your 6DOF build plan

Write a one-page build plan for your arm that maps every Stage 5 fundamental to a concrete decision, check your power numbers, and complete the single-servo rehearsal for at least one servo.

Deliverables

  • A joint table for your actual kit (J1–J6): motion, type, servo model, estimated holding torque and soft limits.
  • Your `readiness_check.py` output with your real servo stall current in the power check.
  • Your pre-flight checklist (10 lines max) and your build log from the single-servo rehearsal.
  • A list of which course chapter you will start with and which Stage 5 lessons you will keep open beside you.

Do this, step by step

  1. Make a joint table for your kit (J1–J6): motion, joint type, servo model, estimated holding torque and soft limits.
  2. Find your servos’ stall current in the datasheet and put it into the power check in readiness_check.py; run it.
  3. Size the supply: add up the stall currents of the servos that can stall together and add margin.
  4. Rehearse with one servo: supply off, wire it (separate supply, common ground, signal only from the pin), centre it, then sweep slowly inside soft limits.
  5. Write a 10-line pre-flight checklist and the build log of your rehearsal, and choose which 6DOF course chapter you will start with.

Stuck? Hints, one at a time

NoteTry the task first. Read one hint, try again, and only then read the next one.
  1. Hint 1: Get your kit’s parts list first (the course’s Bill of Materials chapter helps). Write each servo’s model and datasheet torque at your voltage.
  2. Hint 2: Estimate the shoulder torque with gear_torque.py from Lesson 5 using your link lengths.
  3. Hint 3: Soft limits: start conservative (for example 20°–160°) and widen later after calibration.
  4. Hint 4: Your checklist should cover: area clear, supply voltage, common ground, e-stop test, soft limits loaded, one joint at a time.

Challenges (pick by level)

  • 🟢 Easy: Write J1–J6 for your kit with R or “gripper” for each.
  • 🟢 Easy: Compute the worst-case current for three stalled servos at 2 A and three moving at 0.5 A. Does a 10 A supply pass with 25% headroom?
  • 🟡 Medium: Measure one servo’s current at rest, moving and lightly resisted (Lesson 2 method).
  • 🟡 Medium: Draw the full power and signal wiring for six servos and a PCA9685 (the course’s Controller Board & Wiring chapter will check you).
  • 🟠 Hard-ish: Estimate the holding torque for J2, J3 and J4 at full reach with your real masses and compare with your servos.
  • 🔴 Hard: Write a small Python tool that reads your joint table and prints a warning for any joint whose required torque exceeds 50% of its servo’s rating.
  • ⚫ Expert: Plan the first programmed motion (the course’s First Programmed Motions chapter): a pick-and-place between two points in the sweet spot, with both elbow solutions checked against the table and keep-out zones.

Next step

One lesson left. In Lesson 15 — Capstone: Design Your First Robot you put the whole stage together: design a small robot on paper, review it against every fundamental, fix what fails, and present it like an engineer. Then head to the [6DOF arm course](/chapter/intro-safety) when you are ready.

Look back: Lesson 13: Safety, Limits & Operating Envelope. Next: Lesson 15: Capstone: Design Your First Robot. Related: Stage 6 — 6DOF Arm and Stage 4 — Electronics.

Sources

  • AIHUB 6DOF Arm course on this site: [What is a 6DOF Arm & Safety](/chapter/intro-safety), [Servos & Power](/chapter/servos-power), [Controller Board & Wiring](/chapter/controller-wiring), [Calibration & Testing](/chapter/calibration-testing) — MG996R-class servos for base/shoulder; Arduino-class MCU with direct PWM or a PCA9685; separate 5–6 V supply rated ≥ 10 A with a common ground; stall currents above 1–2 A per servo.
  • Adafruit Learn: 16-Channel PWM/Servo Driver — PCA9685 board: VCC is logic power (3–5 V); V+ supplies the servos; provide 5–6 VDC for servos; default I²C address 0x40.
  • SparkFun Learn: Hobby Servo Tutorial — current rises with load (an ampere or more); supply sag can reset microcontrollers; check VCC while servos move.
  • Arduino Servo library API — attach() and write().
  • OSHA Technical Manual, Section IV Chapter 4 — reduced speed while teaching; unexpected movement as a hazard.
  • Photos: Wikimedia Commons (credits under each image).

Self-attested for now — keep artifacts in your lab notebook.

Complete

Today's goal

0 of 1 done today

0-day streak
Daily goal:lessons, quizzes or assignments a day

Mark this lesson complete when you have worked the experiment, knowledge check, and assignment (even roughly).

Stuck somewhere?

Ask a doubt about this lesson

Saved with this lesson's id and your email so we can reply. Privacy · or email contact@aihubstation.in