Stage 05 · Lesson 15/15

Robotics Fundamentals · Lesson 15

Capstone: Design Your First Robot

Est. 75–100 min

Why

Why a capstone design matters

This capstone puts all fifteen lessons together. You will not just *learn* robotics fundamentals; you will use them to design a robot on paper: choose its joints, check its reach, size its shoulder servo, choose its sensors, plan its control loop, power it safely and give it a gripper that actually holds the part. Then you will review the design honestly, fix what fails and present it like an engineer.

By the end you will be able to: turn a task into a DOF count and a workspace; size the most loaded joint with a safety factor; pick proprioceptive and exteroceptive sensors; choose a loop rate; plan power, e-stop and soft limits; size a friction gripper; run a ten-rule design review; and present a design with numbers, not adjectives.

Three children lying on a colourful rug, chins on their hands, watching a small home-made robotic cat built from wooden parts, servos and an exposed circuit board with wires
School students watching the robotic cat they built themselves — wood, servos, wires and a microcontroller board. Your capstone starts exactly like this: a simple idea, real parts and a lot of careful checking.Photo: Maksim Popov · CC BY 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Concept

A design review in ten questions

Think of a design review like a doctor’s check-up for your robot. The doctor doesn’t say “you look healthy”; she checks pulse, blood pressure, temperature and weight against numbers. A design review does the same: each rule is a measurable question from a Stage 5 lesson, and the answer is PASS or FIX — never “looks fine”.

From task to design: six steps

  1. 1. Write the task in one line

    “Pick a 50 g bottle from the shelf and place it on the counter, 15–22 cm away, at table height.”

  2. 2. Count the DOF

    Position in a vertical plane (2) + the gripper’s pitch to keep the bottle upright (1) = 3 DOF → three revolute joints plus a gripper (Lessons 3, 4).

  3. 3. Size the workspace

    Links long enough that the farthest target sits within about 90% of full reach — the sweet spot, away from the outer edge (Lesson 9).

  4. 4. Size the shoulder

    Holding torque = Σ mass × g × distance, times a safety factor of 2. Choose a servo above that (Lesson 5).

  5. 5. Choose senses and loop

    Proprioception (servo pot) to know joint angles; exteroception (ultrasonic or a limit switch) to know the world; a loop of at least 20 Hz (Lessons 6–8).

  6. 6. Make it safe

    Separate servo supply, a hardware e-stop that cuts servo power, soft limits, and a gripper force that holds with margin (Lessons 2, 11, 13).

The ten-rule review

Each rule comes from one lesson
#RulePass when…Lesson
1DOF matches taskjoints ≥ task DOF3, 4
2Reach covers targetsfarthest target ≤ 90% of L1 + L29
3Shoulder torqueservo ≥ 2 × Σ m g d5
4Proprioceptionencoder or servo pot6
5Exteroceptionultrasonic, camera or limit switch6, 7
6Loop rate≥ 20 Hz7, 8
7Separate servo supplynot the Arduino 5 V pin2
8Hardware e-stopcuts servo supply13
9Soft joint limitsset in code13
10Gripper holds part2 × F × μ ≥ 2 × m g11

τ_shoulder = 2 × g × (m₁d₁ + m₂d₂ + m₃d₃)

  • For the FIXED canteen design: masses 0.08, 0.06 and 0.05 kg at 0.07, 0.20 and 0.26 m from the shoulder → 2 × 9.81 × 0.0306 ≈ 0.60 N·m. A 1.0 N·m servo passes. (The 20 Hz loop rule and the safety factor of 2 are this course’s teaching choices, not universal standards.)
Two student-built VEX competition robots on a grey floor, made of perforated aluminium channels with green-wheeled drive bases, motors, wires and team-number plates reading 11462D and 11462B
Two VEX Robotics Competition robots built by a student team. Every frame, motor and wire was a design decision — and teams re-check their designs after every match. That’s the habit this capstone builds.Photo: Noah Wulf · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Visual

Visualise it: build a robot from parts

Build a robot from parts: choose its body, sensors, actuators and controller, and see how each choice affects what it can do — the same thinking as your design sheet.

Mini capstone · Design your first robot

Robot type

Sensors (multi-select)

Controller

Actuator class

Power approach

Generated architecture summary

Type: Arm
Sensors: Encoders, Distance
Controller: MCU only
Actuation: Hobby servos
Power: USB logic + separate motor PSU

Architecture:
  World → [Encoders, Distance] → [MCU only] → [Hobby servos] → World
  MCU owns the fast loop; keep tasks bounded and measured.
  Power: size for stall/peak current; share ground with logic; never power motors from a weak USB port alone.

Code lab

Code lab: the ten-rule design review

design_review.py runs all ten Stage 5 rules over two versions of the canteen robot: the DRAFT from the story and the FIXED version after the team’s week of changes. Each rule prints PASS or FIX with the numbers behind it. Run it with python3 design_review.py.

design_review.py · Python
"""design_review.py - capstone check for "Design Your First Robot".
Runs the Stage 5 rules over a DRAFT and a FIXED design and prints PASS / FIX for each."""
import math

G = 9.81

def review(d):
    out = []
    dof = sum(1 for j in d["joints"] if j in "RP")
    out.append(("DOF matches task", dof >= d["task_dof"], f"{dof} joints for a {d['task_dof']}-DOF task"))
    L1, L2 = d["links"]
    far = max(math.hypot(*p) for p in d["targets"])
    out.append(("Reach covers targets", far <= (L1 + L2) * 0.9, f"farthest target {far*100:.1f} cm vs 90% of {(L1+L2)*100:.0f} cm"))
    need = sum(m * dist for m, dist in d["shoulder_loads"]) * G * 2
    out.append(("Shoulder torque (2x SF)", d["shoulder_servo_nm"] >= need, f"need {need:.2f} N.m, servo {d['shoulder_servo_nm']} N.m"))
    out.append(("Proprioception", any(s in d["sensors"] for s in ("encoder", "servo pot")), ", ".join(d["sensors"])))
    out.append(("Exteroception", any(s in d["sensors"] for s in ("ultrasonic", "camera", "limit switch")), ", ".join(d["sensors"])))
    out.append(("Loop rate >= 20 Hz", d["loop_hz"] >= 20, f"{d['loop_hz']} Hz"))
    out.append(("Separate servo supply", d["servo_supply"] != "arduino 5V pin", d["servo_supply"]))
    out.append(("Hardware e-stop cuts servo power", d["estop"] == "cuts servo supply", d["estop"]))
    out.append(("Soft joint limits", d["soft_limits"], ""))
    out.append(("Gripper holds part (2x SF)", d["grip_force_n"] * 2 * d["mu"] >= d["part_kg"] * G * 2, f"{d['grip_force_n']} N/finger, mu {d['mu']}"))
    return out

DRAFT = dict(joints="RR", task_dof=3, links=(0.12, 0.10), targets=[(0.15, 0.10), (0.21, 0.05)],
             shoulder_loads=[(0.08, 0.06), (0.06, 0.17), (0.05, 0.22)], shoulder_servo_nm=0.25,
             sensors=["servo pot"], loop_hz=5, servo_supply="arduino 5V pin", estop="software flag",
             soft_limits=False, grip_force_n=0.5, mu=0.4, part_kg=0.05)
FIXED = dict(DRAFT, joints="RRR", links=(0.14, 0.12), shoulder_loads=[(0.08, 0.07), (0.06, 0.20), (0.05, 0.26)], shoulder_servo_nm=1.0, sensors=["servo pot", "ultrasonic"],
             loop_hz=50, servo_supply="separate 6 V 5 A supply, common GND", estop="cuts servo supply",
             soft_limits=True, grip_force_n=2.0)

for name, d in (("DRAFT", DRAFT), ("FIXED", FIXED)):
    res = review(d)
    print(f"== {name}: {sum(ok for _, ok, _ in res)}/{len(res)} pass ==")
    for rule, ok, why in res:
        print(f"  {'PASS' if ok else 'FIX '}  {rule:34s} {why}")
    print()

Output (run with python3 design_review.py)

== DRAFT: 1/10 pass ==
  FIX   DOF matches task                   2 joints for a 3-DOF task
  FIX   Reach covers targets               farthest target 21.6 cm vs 90% of 22 cm
  FIX   Shoulder torque (2x SF)            need 0.51 N.m, servo 0.25 N.m
  PASS  Proprioception                     servo pot
  FIX   Exteroception                      servo pot
  FIX   Loop rate >= 20 Hz                 5 Hz
  FIX   Separate servo supply              arduino 5V pin
  FIX   Hardware e-stop cuts servo power   software flag
  FIX   Soft joint limits                  
  FIX   Gripper holds part (2x SF)         0.5 N/finger, mu 0.4

== FIXED: 10/10 pass ==
  PASS  DOF matches task                   3 joints for a 3-DOF task
  PASS  Reach covers targets               farthest target 21.6 cm vs 90% of 26 cm
  PASS  Shoulder torque (2x SF)            need 0.60 N.m, servo 1.0 N.m
  PASS  Proprioception                     servo pot, ultrasonic
  PASS  Exteroception                      servo pot, ultrasonic
  PASS  Loop rate >= 20 Hz                 50 Hz
  PASS  Separate servo supply              separate 6 V 5 A supply, common GND
  PASS  Hardware e-stop cuts servo power   cuts servo supply
  PASS  Soft joint limits                  
  PASS  Gripper holds part (2x SF)         2.0 N/finger, mu 0.4

Try it: trace the layers of your design — sensing, computing, actuation, power — before you commit to parts.

Interactive · Robot architecture

Feedback: World → Sensors (closed loop)

Sensors — examples

  • •Distance (ultrasonic / ToF)
  • •Encoders / pots
  • •IMU
  • •Camera
  • •Bump / limit switches

Real world

Where students design real robots

  • Student competitions: VEX, FIRST and Student Robotics teams go through design, build, test and fix cycles every season, with judges asking for the numbers behind decisions.
  • Industry design reviews: engineers present requirement, design, calculations and risks before anything is ordered — exactly your design sheet.
  • Indian makers and students: college fests and school labs across India show robots built from 3D-printed parts, hobby servos and microcontrollers — the same parts you have used in this course.
A competition arena with a blue floor, marker-coded walls with square fiducial markers, coloured lines and a raised square platform in the centre
The Student Robotics 2022 competition arena. The square black-and-white markers on the walls are read by the robots’ camera-based vision system — an example of exteroception and frames (Lessons 6 and 10) designed into the environment itself.Photo: Horshamwarrior · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Design studio

Design studio: the one-page robot design sheet

Engineers present designs on one page. Fill this sheet for your robot — on paper, in a notebook or in a document. Every box needs a number or a named part.

Your design sheet
SectionWhat to writeExample (canteen robot, FIXED)
TaskOne line, with distances and massesMove a 50 g bottle 15–22 cm across a counter
PlatformArm, mobile robot, drone… and why (Lesson 12)Fixed desk arm — the counter doesn’t move
JointsType and motion for eachRRR (shoulder, elbow, wrist pitch) + gripper
LinksLengths, total reach14 + 12 cm = 26 cm
ShoulderNeed vs servo0.60 vs 1.0 N·m
SensorsProprioceptive + exteroceptiveServo pots; ultrasonic for “bottle present”
LoopRate and sense–plan–act steps50 Hz: read ultrasonic → choose state → move one step
PowerSupply voltage, current, ground6 V 5 A, common GND
SafetyE-stop, soft limits, keep-outE-stop cuts servo supply; limits 20°–160°
GripperType, force, μTwo-finger friction, 2 N per finger, μ 0.4
  1. Sketch

    Draw the robot from the side with link lengths and joint names. Mark the base frame and the TCP (Lesson 10).

  2. Draw the workspace

    Inner and outer reach circles, the targets, and any keep-out zone (Lessons 9 and 13).

  3. Wiring block diagram

    Supply → e-stop → servos; MCU → signal wires; one common ground. Mark that no servo is powered from a GPIO pin.

  4. Review

    Run your numbers through design_review.py. Fix and re-run until every rule is PASS.

  5. Present

    Explain the design in two minutes: the task, the three hardest numbers and the one trade-off you made.

A small white 3D-printed humanoid robot with an expressive face raising one arm, standing on a glass display table in front of shelves holding other robots
Manav, described as India’s first 3D-printed humanoid robot, at Mumbai Techfest 2015. Every joint you see is a design decision about DOF, torque, sensing and power — the same ten questions in your review.Photo: Jasonprost · CC BY-SA 4.0 · Source: Wikimedia Commons · resized, converted to WebP

Debugging

Debugging a design (before it costs money)

Red flag in the reviewWhat it really meansUsual fix
Fewer joints than task DOFSome poses are impossibleAdd a joint, or simplify the task (e.g. keep the part upright with a passive guide)
Targets at the reach edgeWeak, slow, singular-ish motionLonger links or move the base closer
Shoulder need > servoSag, stall, hot servoStronger servo, gear down, lighter forearm, shorter reach
No exteroceptionRobot is blind to the worldAdd one simple sensor for the key event
Loop too slowLate reactions, jerky motionRemove delay(); non-blocking reads (Lesson 7)
Servos on the Arduino 5 V pinResets, brown-outs, damaged boardSeparate supply, common ground
Software-only e-stopStop fails if code crashesHardware switch in the servo supply (Lesson 13)
Gripper too weakPart slipsMore force, higher-μ pads, or a shape-matched gripper (Lesson 11)

Think

Think about it

Think

Kabir wants to “fix” the shoulder torque in the DRAFT design by keeping the 0.25 N·m servo and reducing the safety factor from 2 to 1. Would that make the robot work? What is a better fix?

Experiment

Try it in the lab: draft, review, fix, present

Sixty to ninety minutes, in a team of two or three if you can. You need the design-robot interactive, design_review.py, paper and a calculator.

Experiment

Draft, review, fix, present

You will need

  • design-robot interactive (below, runs in your browser)
  • `design_review.py`
  • Paper, ruler, compass, calculator
  • Optional: the Lesson 9 reach and Lesson 11 gripper scripts

Steps

  1. Pick a task from your home, school or a shop (or use the canteen bottle). Write it in one line with distances and masses.
  2. In the design-robot interactive, sketch a robot for it. Note the choices that matter most.
  3. Fill in the design sheet and enter your numbers as a new design in `design_review.py`.
  4. Run the review. For every FIX, write the cause and one change. Re-run the whole review after each change.
  5. Present in two minutes to a friend or family member: task, three hardest numbers, one trade-off. Ask them one question to ask you back.

Mini capstone · Design your first robot

Robot type

Sensors (multi-select)

Controller

Actuator class

Power approach

Generated architecture summary

Type: Arm
Sensors: Encoders, Distance
Controller: MCU only
Actuation: Hobby servos
Power: USB logic + separate motor PSU

Architecture:
  World → [Encoders, Distance] → [MCU only] → [Hobby servos] → World
  MCU owns the fast loop; keep tasks bounded and measured.
  Power: size for stall/peak current; share ground with logic; never power motors from a weak USB port alone.

Most first drafts fail several rules. The fixes interact — longer links need more torque, stronger servos need more current. Writing the numbers down is what turns a cool sketch into a robot that can actually be built.

Knowledge check

Check your understanding

Knowledge check

1. Your task needs a 3-DOF motion and your design has 2 revolute joints. The review says…

2. With links of 14 cm and 12 cm, the farthest target should be at most about…

3. Making the links longer usually makes the shoulder torque…

4. Which pair gives both proprioception and exteroception?

5. Why is a “software flag” e-stop a FIX?

6. A two-finger gripper squeezes 2 N per finger with μ = 0.4. Friction available ≈ 2 × 2 × 0.4 = 1.6 N. A 50 g part weighs about 0.49 N. With a safety factor of 2, does it hold?

7. Servos powered from the Arduino 5 V pin is a FIX because…

8. After fixing one rule, you should…

9. A good two-minute design presentation focuses on…

10. What comes after Stage 5?

Mini assignment

Capstone assignment

Mini assignment

Capstone: design, review and present your first robot

Design a small robot for a real task of your choice. Produce a one-page design sheet, run it through the ten-rule review until every rule passes honestly, and present it in two minutes.

Deliverables

  • Your one-line task with distances and masses.
  • A side sketch with link lengths, joint names, base frame, TCP and the workspace circles with targets.
  • The completed design sheet (all ten rows filled with numbers or named parts).
  • The `design_review.py` output for your DRAFT and your FIXED design, with one line per FIX explaining the change.
  • A wiring block diagram: supply → e-stop → servos, MCU signals, common ground, no servo powered from a GPIO pin.
  • A two-minute presentation (written script or short recording) naming one trade-off you made.

Do this, step by step

  1. Write your task in one line with real distances and masses (for example “move a 50 g eraser 20 cm across a desk”).
  2. Sketch the robot from the side: link lengths, joint names, base frame, TCP and workspace circles with the targets marked.
  3. Fill all ten rows of the design sheet with numbers or named parts.
  4. Run design_review.py on your DRAFT, fix each failed rule, and run it on your FIXED design until every rule passes honestly.
  5. Draw the wiring block diagram (supply → e-stop → servos, MCU signals only, common ground) and present the design in two minutes, naming one trade-off.

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: Keep the task small. “Move a 50 g object 20 cm” is a great capstone; “a robot that cooks dinner” is not.
  2. Hint 2: Count the DOF from what the part must do: position in a plane is 2; keeping it upright adds 1.
  3. Hint 3: For the shoulder, list every mass (servos, links, gripper, part) and its distance from the shoulder at full reach. Multiply, add, × 9.81 × 2.
  4. Hint 4: If two rules keep fighting (reach vs torque), move the robot’s base closer to the targets — it is often the cheapest fix.

Challenges (pick by level)

  • 🟢 Easy: Change the canteen robot’s part to 100 g. Which rules fail? Fix them.
  • 🟢 Easy: Draw the workspace of the FIXED design (inner and outer circle) and mark both targets.
  • 🟡 Medium: Add an eleventh rule to design_review.py: supply current ≥ 1.25 × worst-case current.
  • 🟡 Medium: Design a mobile version (a small wheeled robot that carries the bottle) and compare it with the arm using the Lesson 12 platform matrix.
  • 🟠 Hard-ish: Add a keep-out zone (for a person’s hand at the counter) and check your planned path against it with envelope_guard.py from Lesson 13.
  • 🔴 Hard: Make design_review.py read designs from a JSON file and print a short report you can paste into your design sheet.
  • ⚫ Expert: Build a cardboard-and-servo prototype of your FIXED design following every bench rule, and log what the review missed (there is always something).

Next step

🎉 You have completed Stage 5 — Robotics Fundamentals. Next, Stage 7 — Control Systems & PID starts with [Why Robots Need Control](/learn/stage-07/why-robots-need-control): you will turn Lesson 8’s simple proportional correction into proper PID control so joints move precisely and settle without wobbling. Ready to build in metal? Start the [6DOF arm course](/chapter/intro-safety) with your capstone sheet beside you.

Look back: Lesson 14: Bridge to the 6DOF Arm and Lesson 13: Safety, Limits & Operating Envelope. You have finished Stage 5! Next: Stage 7 — Control Systems & PID and the Stage 6 — 6DOF Arm course. Related: Stage 8 — Kinematics & IK and Stage 9 — Trajectory Planning.

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