Stage 08 · Lesson 15/15

Kinematics & Inverse Kinematics · Lesson 15

Capstone: Design & Solve the Kinematics of Your 6DOF Robot

Est. 2–3 hours

Why

Why this capstone matters

In Lessons 1–14 you learned each piece on its own: frames, rotations, transforms, FK, DH tables, poses, workspace, analytical and numerical IK, and how to choose answers and avoid singularities. A real robot needs all of them together, in the right order, with checks that catch mistakes before the motors move. This capstone joins them into one pipeline for your arm, and makes you *prove* it works with numbers.

By the end you will have: a measured and validated DH model of your arm; an IK function for straight-down picks that is checked by FK; a solution-choice rule; a singularity and joint-limit guard; a straight-line path checker; and a printed gate report that ends with CAPSTONE PASS — plus one honest failure case that your system correctly refuses.

A small transparent acrylic robot arm with blue micro servos, a two-finger gripper and jumper wires, on a white desk
A small Arduino robot arm with five degrees of freedom (base, shoulder, elbow, wrist, gripper) — the same kind of arm this capstone is designed for. Its kinematics is exactly what you will model, solve and check.Photo: Nicolò Bertuccioli · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Concept

The full kinematics pipeline, with pass/fail gates

The seven gates

GateWhat it checksFrom lesson
G1The DH table reproduces 4 poses you measured with a ruler (error < 0.01 cm in code, < 0.5 cm on the bench)8, 9
G2Every frame’s rotation is proper (det R = 1)3, 4
G3Each target is inside the reach band for the chosen tool direction11
G4The IK answer, put back through FK, lands on the target12, 13
G5The answer is inside joint limits and the elbow stays above the table11, 14
G6The pose is not near a singularity (|sin q3| > 0.17)14
G7Straight-line moves keep one elbow family and no joint jumps more than 5° per 0.5 cm14

Think of it like a railway signal system. The train (your arm) moves only when every signal on the route is green. One red signal — an unreachable target, a joint past its limit, a pose near a singularity — and the train waits. That is what makes the system safe, not luck.

Order matters

  1. Measure

    Measure link lengths with a ruler or vernier caliper and note each joint’s zero and direction.

  2. Model

    Write the DH table (Lesson 8–9). Run G1 and G2 before anything else — if the model is wrong, every later answer is wrong.

  3. Plan

    List the job as tip targets (above tray, pick, lift, over box, place). Run G3 for each.

  4. Solve

    Use IK for each target, then G4 (FK check) and G5 (limits, collisions).

  5. Choose

    If several answers pass, take the one nearest the current pose (Lesson 14).

  6. Guard

    Run G6 for singularities and G7 for every straight-line move between targets.

  7. Move

    Only now send angles to the servos — slowly, with the STOP command ready.

Visual

Visualise it: run the capstone checklist

Tick the checklist honestly, then solve targets until the FK error is under the gate: CAPSTONE PASS. Educational 2R stand-in, simplified.

Interactive · Kinematics capstone (integrated FK/IK)

Design & solve a 2R educational arm (stand-in for your 6DOF position chain). Pass when checklist + FK residual ≤ 0.5.

Target

(110, 40)

FK err

0.000

Solutions

2

Status

ok

Capstone pending — checklist + err gate

Code lab

Code lab: capstone_kinematics.py

capstone_kinematics.py is the whole pipeline in one file. It validates the DH model, solves a five-step pick-and-place job with straight-down IK, chooses the nearest valid answer, checks singularity margin, checks every straight-line move in 0.5 cm steps, and finally confirms that an out-of-reach target is refused. Change the four lengths and the joint limits to your arm’s numbers.

capstone_kinematics.py · Python
# capstone_kinematics.py - Stage 8 capstone: design, validate and solve the kinematics of your arm.
# One pipeline, with PASS/FAIL gates you can show to someone else:
#   G1 DH table reproduces 4 ruler poses (Lesson 9)          G2 every frame's R is a proper rotation
#   G3 each pick target is inside the straight-down band      G4 IK answer verified by FK  (< 0.01 cm)
#   G5 answer inside joint limits, elbow above the table      G6 not near a singularity (|sin q3| > 0.17)
#   G7 straight-line moves (0.5 cm steps) keep one elbow family, largest joint move per step < 5 deg
# EXAMPLE arm (cm). Replace the numbers with YOUR measured arm.
import math

D1, L2, L3, L4 = 9.0, 10.5, 9.8, 14.0
DH = [(0, D1, 0, 90), (0, 0, L2, 0), (0, 0, L3, 0), (90, 0, 0, 90), (0, L4, 0, 0)]   # (offset, d, a, alpha)
LIM = [(-90, 90), (0, 180), (-150, 0), (-120, 90), (-90, 90)]                       # degrees
TOL_FK, MIN_SIN, MAX_STEP, STEP_CM = 0.01, 0.17, 5.0, 0.5
results = []


def gate(name, ok, note=""):
    results.append(ok)
    print(f"  [{'PASS' if ok else 'FAIL'}] {name}{'  - ' + note if note else ''}")


def dh(th, d, a, al):
    ct, st = math.cos(math.radians(th)), math.sin(math.radians(th))
    ca, sa = math.cos(math.radians(al)), math.sin(math.radians(al))
    return [[ct, -st * ca, st * sa, a * ct], [st, ct * ca, -ct * sa, a * st], [0, sa, ca, d], [0, 0, 0, 1]]


def mul(A, B):
    return [[sum(A[i][k] * B[k][j] for k in range(4)) for j in range(4)] for i in range(4)]


def fk(q):
    T = [[float(i == j) for j in range(4)] for i in range(4)]
    frames = []
    for qi, (off, d, a, al) in zip(q, DH):
        T = mul(T, dh(qi + off, d, a, al))
        frames.append(T)
    return frames


def pos(T):
    return tuple(T[i][3] for i in range(3))


def proper(T):
    R = [r[:3] for r in T[:3]]
    det = (R[0][0] * (R[1][1] * R[2][2] - R[1][2] * R[2][1]) - R[0][1] * (R[1][0] * R[2][2] - R[1][2] * R[2][0])
           + R[0][2] * (R[1][0] * R[2][1] - R[1][1] * R[2][0]))
    return abs(det - 1) < 1e-9


def ik_down(x, y, z):
    """All straight-down answers (J1..J5) for tip (x, y, z); J5 = 0."""
    j1 = math.degrees(math.atan2(y, x))
    rw, zw = math.hypot(x, y), z + L4 - D1
    d2 = rw * rw + zw * zw
    c = (d2 - L2 * L2 - L3 * L3) / (2 * L2 * L3)
    if abs(c) > 1:
        return []
    out = []
    for s in (1, -1):
        j3 = math.degrees(s * math.acos(c))
        j2 = math.degrees(math.atan2(zw, rw) - math.atan2(L3 * math.sin(math.radians(j3)), L2 + L3 * math.cos(math.radians(j3))))
        out.append((j1, j2, j3, -90 - j2 - j3, 0.0))
    return out


print("Stage 8 capstone - example arm D1 9, L2 10.5, L3 9.8, L4 14 cm (classic DH)\n")
print("1) Validate the model")
checks = [((0, 0, 0, 0, 0), (34.3, 0, 9.0)), ((0, 90, 0, 0, 0), (0, 0, 43.3)),
          ((0, 90, -90, -90, 0), (9.8, 0, 5.5)), ((90, 0, 0, 0, 0), (0, 34.3, 9.0))]
worst = max(math.dist(pos(fk(q)[-1]), exp) for q, exp in checks)
gate("G1 DH table matches 4 ruler poses", worst < 0.01, f"worst {worst:.1e} cm")
gate("G2 all frames are proper rotations", all(proper(T) for q, _ in checks for T in fk(q)))

def best(target, current):
    """Verified answer (G4), inside limits with elbow above table (G5), nearest to current pose."""
    good = []
    for q in ik_down(*target):
        frames = fk(q)
        err = math.dist(pos(frames[-1]), target)
        if err < TOL_FK and all(lo <= v <= hi for v, (lo, hi) in zip(q, LIM)) and frames[1][2][3] > 0:
            good.append((q, err))
    if not good:
        return None, None
    return min(good, key=lambda g: max(abs(a - b) for a, b in zip(g[0], current)))


def family(q):
    return "elbow-up" if q[2] < 0 else "elbow-down"


print("\n2) Solve a pick-and-place job (gripper straight down)")
job = [("home above tray", (14.0, -6.0, 6.0)), ("pick sweet", (14.0, -6.0, 1.0)),
       ("lift", (14.0, -6.0, 6.0)), ("over box", (10.0, 9.0, 6.0)), ("place", (10.0, 9.0, 2.0))]
current, prev_t = None, None
for name, target in job:
    gate(f"G3 '{name}' {target} reachable straight down", bool(ik_down(*target)))
    q, err = best(target, current or (0, 60, -60, -90, 0))
    if q is None:
        gate(f"G4/G5 '{name}' verified answer inside limits", False)
        break
    s3 = abs(math.sin(math.radians(q[2])))
    gate(f"G4/G5 '{name}' q = ({', '.join(f'{v:.1f}' for v in q)})", True, f"FK error {err:.0e} cm, {family(q)}")
    gate(f"G6 '{name}' away from singularity", s3 > MIN_SIN, f"|sin q3| = {s3:.2f}")
    if current is not None:
        n = max(1, math.ceil(math.dist(prev_t, target) / STEP_CM))
        worst, same, path_q = 0.0, True, current
        for k in range(1, n + 1):
            p = tuple(a + (b - a) * k / n for a, b in zip(prev_t, target))
            qk, _ = best(p, path_q)
            if qk is None:
                same = False
                break
            worst = max(worst, max(abs(a - b) for a, b in zip(qk, path_q)))
            same = same and family(qk) == family(current)
            path_q = qk
        gate(f"G7 line to '{name}': {n} steps, largest joint step {worst:.1f} deg", same and worst < MAX_STEP)
    current, prev_t = q, target

print("\n3) An honest failure case")
far = (32.0, 0.0, 1.0)
gate(f"far target {far} correctly REJECTED", not ik_down(*far), "outside the straight-down band - do not move")

print(f"\nCAPSTONE {'PASS' if all(results) else 'NOT YET'}: {sum(results)}/{len(results)} gates passed")

Output (run with python3 capstone_kinematics.py)

Stage 8 capstone - example arm D1 9, L2 10.5, L3 9.8, L4 14 cm (classic DH)

1) Validate the model
  [PASS] G1 DH table matches 4 ruler poses  - worst 3.2e-15 cm
  [PASS] G2 all frames are proper rotations

2) Solve a pick-and-place job (gripper straight down)
  [PASS] G3 'home above tray' (14.0, -6.0, 6.0) reachable straight down
  [PASS] G4/G5 'home above tray' q = (-23.2, 57.3, -44.5, -102.8, 0.0)  - FK error 4e-15 cm, elbow-up
  [PASS] G6 'home above tray' away from singularity  - |sin q3| = 0.70
  [PASS] G3 'pick sweet' (14.0, -6.0, 1.0) reachable straight down
  [PASS] G4/G5 'pick sweet' q = (-23.2, 56.3, -72.6, -73.8, 0.0)  - FK error 4e-15 cm, elbow-up
  [PASS] G6 'pick sweet' away from singularity  - |sin q3| = 0.95
  [PASS] G7 line to 'pick sweet': 10 steps, largest joint step 4.1 deg
  [PASS] G3 'lift' (14.0, -6.0, 6.0) reachable straight down
  [PASS] G4/G5 'lift' q = (-23.2, 57.3, -44.5, -102.8, 0.0)  - FK error 4e-15 cm, elbow-up
  [PASS] G6 'lift' away from singularity  - |sin q3| = 0.70
  [PASS] G7 line to 'lift': 10 steps, largest joint step 4.1 deg
  [PASS] G3 'over box' (10.0, 9.0, 6.0) reachable straight down
  [PASS] G4/G5 'over box' q = (42.0, 69.2, -62.3, -96.9, 0.0)  - FK error 4e-15 cm, elbow-up
  [PASS] G6 'over box' away from singularity  - |sin q3| = 0.89
  [PASS] G7 line to 'over box': 32 steps, largest joint step 3.4 deg
  [PASS] G3 'place' (10.0, 9.0, 2.0) reachable straight down
  [PASS] G4/G5 'place' q = (42.0, 67.4, -83.4, -74.0, 0.0)  - FK error 6e-15 cm, elbow-up
  [PASS] G6 'place' away from singularity  - |sin q3| = 0.99
  [PASS] G7 line to 'place': 8 steps, largest joint step 3.3 deg

3) An honest failure case
  [PASS] far target (32.0, 0.0, 1.0) correctly REJECTED  - outside the straight-down band - do not move

CAPSTONE PASS: 22/22 gates passed

Try it: tick each checklist item only when you have really done it, then hit a preset and a custom target with FK error under the gate. Also try an unreachable target. (Educational 2R stand-in — simplified.)

Interactive · Kinematics capstone (integrated FK/IK)

Design & solve a 2R educational arm (stand-in for your 6DOF position chain). Pass when checklist + FK residual ≤ 0.5.

Target

(110, 40)

FK err

0.000

Solutions

2

Status

ok

Capstone pending — checklist + err gate

Real world

In the real world

  • Robot makers publish DH tables for their arms — Universal Robots, for example, publishes the DH parameters of its UR arms (Lesson 9). Programmers start from a model like that, just as you did.
  • Palletizing cells repeat the same pick-and-place pattern for hours. A small model or path mistake would repeat on every box, so the job is checked carefully before full speed.
  • The professional pipeline is the same as yours: model → FK → IK → choose an answer → avoid singularities → plan the path. Textbooks such as *Modern Robotics* follow this order too.
A labelled product drawing of a collaborative palletiser: a UR10e cobot on a lift column with a vacuum gripper, an operator screen, a small conveyor and a wooden pallet
A collaborative palletiser built around a UR10e cobot: boxes arrive at a known pick point and go to known places on the pallet — a pick-and-place job like your capstone, repeated many times.Photo: CollaborativePalletizer · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Bench build

Bench build: a guarded pick-and-place on your arm

capstone_pick_place.ino runs the same gates on an Arduino UNO. Type P 14 -6 to pick at (14, −6) cm and D 10 9 to drop at (10, 9). The arm moves up to a safe height, down, grips, and back up — every move a straight line in 0.5 cm steps. Before moving, it checks the whole line; if any step fails reach, limits, singularity margin or the FK check, it refuses and prints why. Typing S stops it at once; H re-arms and goes home.

  1. Power

    All five servos on a separate 5–6 V supply that can give 3 A or more; supply GND joined to Arduino GND. Signals: base D3, shoulder D5, elbow D6, wrist D9, gripper D10.

  2. Calibrate

    Set ZERO_US and US_PER_DEG for each servo from your Lesson 9 calibration. Check the sign of each joint.

  3. Dry run

    Run capstone_kinematics.py with your numbers first. Only use targets that pass there.

  4. First move

    With a hand on the servo supply switch, type H. Then P and D with small targets near the middle of the workspace.

  5. Test the guard

    Type P 32 0 — the sketch must print REFUSED and not move.

capstone_pick_place.ino · Arduino C++
// capstone_pick_place.ino - Stage 8 capstone: a guarded straight-down pick-and-place.
// Arduino Uno, servos wired directly: J1 base D3, J2 shoulder D5, J3 elbow D6,
// J4 wrist D9, gripper D10. ALL servos on a SEPARATE 5-6 V supply (>= 3 A),
// common GND with the Arduino. Never power servos from the Arduino 5 V pin.
// Serial Monitor 115200: type "P x y" (pick at x,y cm), "D x y" (drop), "H" (home), "S" (STOP).
// The arm moves only when EVERY gate passes: reach, joint limits, FK check, singularity margin.
#include <Servo.h>
#include <math.h>

const float D1 = 9.0, L2 = 10.5, L3 = 9.8, L4 = 14.0;   // measure YOUR arm (cm)
const float Z_SAFE = 6.0, Z_PICK = 1.0, STEP_CM = 0.5, MIN_SIN = 0.17;
const float LO[4] = {-90, 0, -150, -120}, HI[4] = {90, 180, 0, 90};
const int PIN[5] = {3, 5, 6, 9, 10};
const float ZERO_US[4] = {1500, 600, 2400, 1500}, US_PER_DEG[4] = {10.3, 10.3, 10.3, 10.3};  // calibrate (Lesson 9)
const int GRIP_OPEN = 1300, GRIP_CLOSED = 1800;
Servo sv[5];
float q[4] = {0, 60, -60, -90};
float tip[3] = {14.0, 0.0, Z_SAFE};
bool stopped = false;

bool ikDown(float x, float y, float z, float out[4]) {
  float j1 = atan2(y, x);
  float rw = sqrt(x * x + y * y), zw = z + L4 - D1;
  float c = (rw * rw + zw * zw - L2 * L2 - L3 * L3) / (2 * L2 * L3);
  if (fabs(c) > 1) return false;                           // gate: reach
  float j3 = -acos(c);                                     // elbow-up family only
  float j2 = atan2(zw, rw) - atan2(L3 * sin(j3), L2 + L3 * cos(j3));
  out[0] = degrees(j1); out[1] = degrees(j2); out[2] = degrees(j3);
  out[3] = -90 - out[1] - out[2];
  for (int i = 0; i < 4; i++) if (out[i] < LO[i] || out[i] > HI[i]) return false;   // gate: limits
  if (fabs(sin(j3)) < MIN_SIN) return false;               // gate: singularity margin
  float r = L2 * cos(j2) + L3 * cos(j2 + j3);              // gate: FK check of the wrist centre
  float zz = D1 + L2 * sin(j2) + L3 * sin(j2 + j3) - L4;
  return fabs(r - rw) < 0.01 && fabs(zz - z) < 0.01 && L2 * sin(j2) + D1 > 0;  // elbow above table
}

void writeJoints(const float a[4]) {
  for (int i = 0; i < 4; i++) sv[i].writeMicroseconds((int)(ZERO_US[i] + (i == 2 ? -1 : 1) * a[i] * US_PER_DEG[i]));
}

void checkStop() {
  if (Serial.available() && toupper(Serial.peek()) == 'S') { Serial.read(); stopped = true; Serial.println("STOP - send H to re-arm"); }
}

bool lineTo(float x, float y, float z) {
  float d = sqrt(sq(x - tip[0]) + sq(y - tip[1]) + sq(z - tip[2]));
  int n = max(1, (int)ceil(d / STEP_CM));
  float sol[4];
  if (!ikDown(x, y, z, sol)) { Serial.println("REFUSED: target fails a gate"); return false; }
  for (int k = 1; k <= n; k++) {                           // check the WHOLE line first
    float t = (float)k / n;
    if (!ikDown(tip[0] + (x - tip[0]) * t, tip[1] + (y - tip[1]) * t, tip[2] + (z - tip[2]) * t, sol)) {
      Serial.print("REFUSED: path fails a gate at step "); Serial.println(k); return false;
    }
  }
  float start[3] = {tip[0], tip[1], tip[2]};
  for (int k = 1; k <= n; k++) {
    checkStop(); if (stopped) return false;
    float t = (float)k / n;
    ikDown(start[0] + (x - start[0]) * t, start[1] + (y - start[1]) * t, start[2] + (z - start[2]) * t, q);
    writeJoints(q);
    tip[0] = start[0] + (x - start[0]) * t; tip[1] = start[1] + (y - start[1]) * t; tip[2] = start[2] + (z - start[2]) * t;
    delay(40);                                             // slow: about 12 cm/s
  }
  return true;
}

void pickOrDrop(float x, float y, bool pick) {
  if (!lineTo(x, y, Z_SAFE) || !lineTo(x, y, Z_PICK)) return;
  sv[4].writeMicroseconds(pick ? GRIP_CLOSED : GRIP_OPEN);
  delay(500);
  if (lineTo(x, y, Z_SAFE)) Serial.println(pick ? "PICKED" : "PLACED");
}

void setup() {
  Serial.begin(115200);
  ikDown(tip[0], tip[1], tip[2], q);
  for (int i = 0; i < 5; i++) sv[i].attach(PIN[i]);
  writeJoints(q);
  sv[4].writeMicroseconds(GRIP_OPEN);
  Serial.println("Capstone ready. P x y | D x y | H | S");
}

void loop() {
  checkStop();
  if (!Serial.available()) return;
  char c = toupper(Serial.read());
  if (c == 'H') { stopped = false; lineTo(14.0, 0.0, Z_SAFE); Serial.println("HOME"); return; }
  if (stopped || (c != 'P' && c != 'D')) return;
  float x = Serial.parseFloat(), y = Serial.parseFloat();
  pickOrDrop(x, y, c == 'P');
}
A steel vernier caliper with its jaws open, lying on a dark surface
A vernier caliper. Measure link lengths joint-centre to joint-centre — gate G1 will tell you if a number is wrong.Photo: Jeremyida002 · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Debugging

Debugging the capstone

SymptomLikely causeFix
G1 failsA link length, joint offset or sign is wrong in the DH tableRe-measure; check each joint’s zero against Lesson 9
All gates pass but the real tip is 1–2 cm offServo calibration (ZERO_US, US_PER_DEG) or play in the jointsRe-calibrate; tighten horns and brackets
Target refused that ‘looks’ reachableOutside the straight-down band, or a joint limitPrint which gate failed; move the target inwards
Elbow flips during a moveSolver switching familiesKeep one family; check G7
Servos jitter or Arduino resetsServos powered from the Arduino, or supply too weakSeparate 5–6 V supply, 3 A+, common ground
Gripper misses objectsZ_PICK too high, or the object’s height not countedMeasure object height; adjust Z_PICK

Think

Think about it

Think

Ritu says, “Our demo worked three times. Why do we still need the gate report?”

Experiment

Capstone build

About 2–3 hours. Do it in order — software gates first, then the bench.

Experiment

Capstone pass

You will need

  • `capstone_kinematics.py` and Python 3
  • Ruler or vernier caliper, graph paper
  • Optional: your arm, separate 5–6 V servo supply (3 A+), Arduino UNO

Steps

  1. Measure your arm and put the numbers in the script. Measure four poses with a ruler and update G1.
  2. Run until G1 and G2 pass. Write down any number you had to correct.
  3. Write your own 5-step job and run until all gates pass.
  4. Add one target that should fail and confirm it is refused.
  5. In the capstone lab above, tick the checklist and hit a preset and a custom target under the error gate.
  6. If you built the arm: run the sketch, measure the real tip error at each target, and compare with the software gates.

Interactive · Kinematics capstone (integrated FK/IK)

Design & solve a 2R educational arm (stand-in for your 6DOF position chain). Pass when checklist + FK residual ≤ 0.5.

Target

(110, 40)

FK err

0.000

Solutions

2

Status

ok

Capstone pending — checklist + err gate

When every gate passes, the arm’s behaviour becomes predictable. When one fails, the report tells you where to look. That is the difference between a demo and an engineered system.

Knowledge check

Check your understanding

Knowledge check

1. Which gate should you run first?

2. What does the FK check (G4) after IK prove?

3. Every target passes, but the elbow flips in the middle of a move. Which gate catches it?

4. The script refuses (32, 0, 1). Is that a failure of the capstone?

5. Why does the sketch check the whole line before it starts moving?

6. How should five servos be powered?

7. All software gates pass but the real tip is 2 cm off. Most likely cause?

Mini assignment

Capstone portfolio

Mini assignment

Capstone portfolio

Submit a short portfolio that proves your arm’s kinematics works — with numbers, not just a video.

Deliverables

  • Your measured lengths, joint zeros and directions, and the DH table.
  • The four ruler poses and the G1/G2 result.
  • Your 5-step job and the full gate report ending in CAPSTONE PASS.
  • One unreachable or unsafe target and proof that it was refused.
  • A note on your arm’s singular poses and how your guard avoids them.
  • If you built the arm: real tip error at each target, and what you calibrated.

Do this, step by step

  1. Measure your arm’s lengths, joint zeros and directions, and put them into DH and LIM in capstone_kinematics.py.
  2. Set the arm to four poses and check them with a ruler (gates G1 and G2). Fix the table until they pass.
  3. Write your own 5-step pick-and-place job and run the script until the full gate report ends in CAPSTONE PASS.
  4. Add one target that is out of reach or below the table, and show that a gate refuses it.
  5. Optional bench: run capstone_pick_place.ino slowly with the gripper empty, measure the real tip at each target and note what you calibrated.

Stuck? Hints, one at a time

NoteTry the task first. Read one hint, try again, and only then read the next one.
  1. Fix the DH table before the job: if G1/G2 fail, nothing later can pass.
  2. Run one gate at a time and read its note; the first red gate is the one to fix.
  3. Keep the arm away from stretched poses in your job so the singularity gate stays green.

Challenges (pick by level)

  • 🟢 Easy: Change the job to pick from three tray positions and place in one box. Keep all gates green.
  • 🟢 Easy: Explain each gate in one line to a friend who has not done this stage.
  • 🟡 Medium: Add an obstacle (a box 5 cm tall) and a gate that refuses any path step whose tip or elbow enters it.
  • 🟠 Hard-ish: Allow tilted gripper picks (45°) using the reach checks from Lesson 11 and compare the usable area.
  • 🔴 Hard: Replace straight-down IK with the numerical solver from Lesson 13 for a free tool orientation, keeping all gates.
  • ⚫ Research: Read *Modern Robotics* Chapters 4–6 and compare the product-of-exponentials model with your DH model for the same arm.

Next step

Congratulations — Stage 8 is complete. You can now describe, solve and check where your arm goes. The next stage moves from *where* to *how*: controlling motion over time — speed, smooth trajectories and feedback — so the arm moves well, not just correctly.

Look back: Lesson 14: Multiple Solutions & Singularities and Lesson 9: Building a DH Table. You have finished Stage 8! Next: Stage 9 L01: Why Robots Need Trajectories. Related: Stage 6 — 6DOF Arm, Stage 7: Capstone: Tune a Robot Joint and Stage 12 — Simulation & Digital Twin.

Sources

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