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
Learn Step by Step
Work the live lessons in order. Each link opens a real Stage 0 lesson page.
- 01What Is a Robot?Lab definition: sense, compute, act, feedback.
- 02Anatomy of a RobotBase, link, joint, DOF, end-effector, frames.
- 03SensorsProprioceptive vs exteroceptive; noise and thresholds.
- 04ActuatorsDC, servo, stepper; current and brownouts.
- 05The Robot BrainMCU vs SBC split; firmware vs high-level software.
- 06Power & CommunicationRails, common ground, serial, noise.
- 07Feedback & ControlOpen vs closed loop; error = target − measured.
- 08Robot TypesManipulators, mobiles, industrial cells.
- 09Simulation vs RealitySim strengths, gaps, and validation habits.
- 10Your Robotics JourneyRoadmap map + Design Your First Robot capstone.
Diagram · Robot Anatomy
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.
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.
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.
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.
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.
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.
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
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.