Stage 00 · Live

Robotics Orientation

Build shared robotics vocabulary — sense, compute, act, feedback — and design a first robot architecture before specialized stages.

Journey · Stage 0 Understand Robot → Stage 1 Math → Stage 2 Program Robot → Stage 3 Linux → Stage 4 Electronics → Stage 5 Robotics Fundamentals → Stage 6 6DOF Arm (flagship). Open now — start here. Guided article below; next recommended: Stage 1 Math.

10 lessonsEffort 7–9 h
0/10 lessons0%

Stage Guide · Orientation

Stage 0 Guided Overview

A human-readable path through Robotics Orientation — vocabulary first, then sensors, actuators, brains, power, and feedback — before Math and the 6DOF flagship.

What You Will Learn

  • Define a robot using sense → compute → act, often with feedback.
  • Name anatomy: base, link, joint, DOF, end-effector, frames.
  • Distinguish proprioceptive vs exteroceptive sensors.
  • Choose actuator classes with current / brownout awareness.
  • Split MCU vs SBC responsibilities and sketch power + communication.
  • Explain open-loop vs closed-loop at an intuition level.
  • Design a first robot architecture (capstone) and map the Master Roadmap.

Why This Matters

Later stages assume shared language. If “DOF,” “end-effector,” and “closed-loop” are fuzzy, wiring, kinematics, and ROS conversations get expensive.

Orientation is short on purpose: build intuition and lab habits before Math, Python, Electronics, and the Stage 6 6DOF arm.

Before You Start

  • No hardware required for Stage 0 — browser lessons and paper sketches are enough.
  • Optional later: Arduino-class MCU docs and a notebook for decisions / failures.
  • Safety habit now: never power motors from a logic USB port or bare GPIO current.
  • Have the Master Roadmap open in another tab so “what’s next” stays concrete.

The Big Picture

Every useful robot in this lab closes a physical loop: sensors report state, a computer decides, actuators change the world, and feedback corrects drift.

Your Stage 6 desktop arm is a serial chain of revolute joints with an end-effector — the same anatomy words apply to mobiles and industrial cells, with different plants and sensors.

Diagram · Sense–Compute–Act

Educational line art: sense → compute → act with a feedback path from the world. Not a photo.
Educational line art: sense → compute → act with a feedback path from the world. Not a photo.

Learn Step by Step

Work the live lessons in order. Each link opens a real Stage 0 lesson page.

  1. 01What Is a Robot?Lab definition: sense, compute, act, feedback.
  2. 02Anatomy of a RobotBase, link, joint, DOF, end-effector, frames.
  3. 03SensorsProprioceptive vs exteroceptive; noise and thresholds.
  4. 04ActuatorsDC, servo, stepper; current and brownouts.
  5. 05The Robot BrainMCU vs SBC split; firmware vs high-level software.
  6. 06Power & CommunicationRails, common ground, serial, noise.
  7. 07Feedback & ControlOpen vs closed loop; error = target − measured.
  8. 08Robot TypesManipulators, mobiles, industrial cells.
  9. 09Simulation vs RealitySim strengths, gaps, and validation habits.
  10. 10Your Robotics JourneyRoadmap map + Design Your First Robot capstone.

Diagram · Robot Anatomy

Educational serial-arm sketch: base, links, joints, end-effector. Line art only.
Educational serial-arm sketch: base, links, joints, end-effector. Line art only.

Real Robotics Example

A warehouse AMR senses with lidar and cameras, computes a navigation stack, and acts through drive motors — closing loops on pose and obstacles.

A desktop 6DOF teaching arm senses joint position (often via hobby-servo pots), computes setpoints on an MCU (and maybe a PC), and acts with metal-gear servos on a dedicated high-current supply — not USB power.

Components / Tools

Orientation names classes of parts. Specs below are teaching notes from verified manufacturer or docs pages — always re-check the sheet for your batch.

  • Arduino-class MCU

    What · Microcontroller board for PWM, ADC, and simple control loops.

    Why · Reliable low-level I/O for hobby robots; common Stage 6 pattern.

    Spec note · See official Arduino docs for your specific board (Uno, Mega, etc.).

    Beginner note · Great first “brain” for servos; pair with a separate motor PSU.

    Official source →

  • Python (later stages)

    What · High-level language used widely in robotics scripting and later course stages.

    Why · Stage 2 builds Python foundations after Orientation + Math.

    Spec note · Official language reference and tutorial live at docs.python.org.

    Beginner note · You do not need Python fluency to finish Stage 0.

    Official source →

  • ROS 2 (later stages)

    What · Robot Operating System 2 — middleware for nodes, topics, and tools.

    Why · Appears in Stage 10 after Linux / trajectory foundations.

    Spec note · Start from the official ROS 2 documentation hub when you reach that stage.

    Beginner note · Mentioned here only as a roadmap landmark — not required in Stage 0.

    Official source →

  • NVIDIA Jetson (later / edge AI)

    What · Embedded GPU computer family for AI-at-the-edge robotics.

    Why · Useful later for vision-heavy or Physical AI paths; not Stage 0 hardware.

    Spec note · Use NVIDIA’s Jetson getting-started hub for your specific developer kit.

    Beginner note · Skip until you need onboard deep learning; MCU + PC is enough early on.

    Official source →

  • PCA9685 PWM / servo driver

    What · I²C 16-channel 12-bit PWM board commonly used to drive many hobby servos.

    Why · Offloads PWM from the MCU when you need many channels.

    Spec note · Adafruit’s learning guide covers wiring, power, and libraries.

    Beginner note · Still needs a dedicated servo power rail — the chip only makes pulses.

    Official source →

  • MG996R-class metal-gear hobby servo

    What · Common metal-gear hobby servo used on many desktop teaching arms.

    Why · Illustrates integrated position control with serious stall current.

    Spec note · TowerPro lists ~4.8–6.6 V, stall on the order of ~1.4 A — treat as a teaching order-of-magnitude; counterfeits vary.

    Beginner note · Never power a bank of these from USB or Arduino 5 V pins.

    Official source →

How It Works

Sense: transducers turn distance, angle, or pixels into signals. Compute: firmware or software turns goals into commands. Act: motors apply force. Feedback: measured error drives the next correction.

Open-loop hopes the command was enough. Closed-loop measures and corrects when friction, battery sag, or payload change the outcome. PID and stability proofs wait for Stage 7 — Orientation only needs the picture.

Diagram · Open vs Closed Loop

Educational comparison: open-loop command path vs closed-loop with sensor feedback.
Educational comparison: open-loop command path vs closed-loop with sensor feedback.

Try It Yourself

  • Classify three machines near you with sense / compute / act / feedback.
  • Sketch a 3-joint planar arm and label base, links, joints, end-effector.
  • Use the distance-sensor and feedback-loop interactives in their lessons.
  • Complete the Design Your First Robot capstone and save the architecture summary.

Simulation

Stage 0 interactives are educational browser widgets — not Gazebo, Isaac, or real hardware. Open the lessons that embed them:

Real Hardware

Safe beginner notes if you peek ahead at kits:

  • Logic (USB / 3.3–5 V MCU) and motor power are different budgets — use a dedicated servo/motor supply sized for stall current.
  • Share a common ground between logic and motor supplies when exchanging PWM / signals.
  • Never drive motors directly from GPIO pins; use drivers / ESCs / servo electronics rated for the load.
  • First power-up: polarity check, current-limited supply if available, clear workspace, know how to cut power.
  • Stage 6 teaches the live 6DOF hardware path when you are ready.

Common Mistakes

  • Calling every appliance a “robot” without sense–compute–act precision.
  • Confusing mechanism DOF with actuated / controllable DOF.
  • Powering servos from USB and blaming “bad code” for brownout resets.
  • Skipping common ground between MCU and motor PSU.
  • Treating simulation demos as proof the real arm will behave identically.

Troubleshooting

  • MCU resets when motors move → check supply current, bulk capacitance, and USB power path.
  • Serial garbage only under load → inspect ground integrity and motor-lead routing near signal wires.
  • Distance sensor “walls” in empty space → wiring, orientation, specular surfaces, wrong units.
  • Joint never reaches target → friction, hard stop, bias/zero error, or insufficient torque.

Mini Assignment

Write a one-page lab note: (1) your definition of a robot, (2) a labeled anatomy sketch of any arm or mobile, (3) a power rule you will not violate, (4) your next stage after Orientation.

Challenge

Design two architectures for the same task (e.g. desk pick-and-place): one MCU-only and one MCU+SBC. List what each brain owns, two messages on the link, and the peak current worry for actuators.

What You Should Understand Now

  • Sense–compute–act (+ feedback) as a working lab definition.
  • Anatomy vocabulary for serial arms and why DOF language matters.
  • Why sensors are uncertain and actuators need real power budgets.
  • Why MCU/SBC splits and closed loops show up everywhere later.
  • Where Stage 0 sits on the Master Roadmap relative to Math and Stage 6.

What's Next?

Recommended next: Stage 1 — Math for Robotics. Stage 6 6DOF remains the flagship hardware path and stays reachable in parallel.

Lessons

End-of-stage quiz · free

Check Stage 0 in one go

One question from each lesson. 70% or more meets the quiz requirement for the stage certificate (certificates are part of AIHUB Pro).