What it means: Human controls every action in real-time via remote control or direct wiring

How it works:

• Human inputs: Joystick, buttons, keyboard commands
• Robot executes: Exact motor/servo movements commanded
• No decisions: Robot has zero decision-making capability
• Like: RC car, wired robotic arm, puppet

Example products (2024-2025):

• Basic RC cars ($20-50)
• DJI Tello drone in manual mode ($100)
• Wired surgical robot (Da Vinci system)

When to use Level 0: Simplest to build, no AI needed, complete human control desired, precise manipulation tasks, entertainment/toys

What it means: Human controls direction, robot handles simple self-preservation behaviors

How it works:

• Human: "Go forward"
• Robot: Moves forward BUT automatically stops if obstacle detected
• Simple if/then rules: "IF obstacle THEN stop"
• No planning: Just reactive safety behaviors

Example products:

• Anki Vector robot ($200-250, discontinued but available used)
• DJI Mini drones with obstacle sensors ($400-500)
• Basic Arduino obstacle-avoiding car kits ($50-80)

Implementation: Arduino + ultrasonic sensor + 20 lines of code. No AI required, just simple conditional logic.

What it means: Robot can perform specific tasks independently under human supervision

How it works:

• Human: Sets goal ("follow this line", "track this color")
• Robot: Executes complete behavior independently
• Human: Monitors and intervenes when needed
• Limited context: Works in structured environments only

Example capabilities:

• Line-following robot that stays on black tape
• Color-tracking robot using Pixy2 camera ($60)
• Wall-following behavior for maze navigation

Real products: Most educational robot kits, Sphero robots ($150-200), Lego Mindstorms line-followers

Implementation: Simple computer vision (Pixy2) or sensor arrays. No machine learning needed.

What it means: Robot handles most situations autonomously but requests human help when uncertain

How it works:

• Robot: Operates independently in known scenarios
• Unknown situation: Robot asks human for guidance
• Example: Roomba that navigates rooms but gets stuck on cables and asks for help
• Decision trees: More complex rule-based behavior

Example products (2024-2025):

• iRobot Roomba j7+ ($800) - navigates, maps, avoids obstacles, alerts when stuck
• Amazon Astro robot ($1,600) - patrols home, calls human when confused
• Warehouse robots (Kiva/Amazon) that navigate but request human intervention for exceptions

Implementation: Requires mapping (SLAM), path planning algorithms, multiple sensors, possibly basic ML for object detection

What it means: Robot operates fully independently within specific, well-defined environments

How it works:

• Operates autonomously: In predefined spaces/scenarios
• Full task completion: Without human supervision
• Limitation: Only in controlled/mapped environments
• AI integration: Machine learning for perception and decision-making

Example products:

• Waymo autonomous taxi (operates in specific mapped cities)
• Boston Dynamics Spot ($75,000) - autonomous facility inspection
• Warehouse robots (Fetch, Locus) - fully autonomous in warehouses
• Agricultural robots (FarmWise) - autonomous weeding in fields

Requirements: Computer vision, machine learning, sophisticated sensors (LIDAR, depth cameras), powerful computing (Jetson Nano $150+)

What it means: Robot operates independently in any environment humans can navigate

How it works:

• No restrictions: Works anywhere without pre-mapping
• General intelligence: Handles novel situations
• Full decision-making: From perception to action without human input
• Self-learning: Adapts to new environments and tasks

Current state (2024-2025):

• Status: Does not exist yet for physical robots
• Closest: Advanced humanoid prototypes (Tesla Optimus, Figure 01) but still in development
• Challenges: Requires AGI (Artificial General Intelligence), not just narrow AI
• Timeline: Experts estimate 10-30+ years away

For makers: Not a realistic goal for hobby projects. Focus on Levels 1-3 for practical robotics.

What it means: You explicitly program every behavior as if/then statements

Example behaviors you can achieve with pure rules:

• Obstacle avoidance: IF distance < 20cm THEN turn right
• Line following: IF left sensor sees black THEN turn left
• Light seeking: IF right sensor brighter THEN turn right
• Wall following: IF too close THEN veer away, IF too far THEN veer closer
• State machines: IF button pressed THEN switch from idle to active mode

Advantages:

• Predictable and debuggable
• Works on simple Arduino boards
• No training data needed
• Immediate behavior modification by changing code

Perfect for: Beginner robots, line followers, obstacle avoiders, simple autonomous behaviors, most educational robotics

What it means: Robot learns patterns from data rather than following explicit rules

When you genuinely need ML:

• Face recognition: Too complex to write rules for every face variation
• Natural speech: Understanding human language requires learning from examples
• Object classification: "Is this a dog or cat?" from camera image
• Gesture recognition: Learning movement patterns from training data
• Adaptive behavior: Robot learns optimal navigation from experience

Requirements:

• More powerful hardware (Raspberry Pi minimum, Jetson Nano $150 ideal)
• Training data (hundreds/thousands of examples)
• ML frameworks (TensorFlow Lite, OpenCV)
• Longer development time

Realistic maker ML: Use pre-trained models (Google Teachable Machine, Edge Impulse) rather than training from scratch

What it means: Use ML for perception, rules for behavior/safety

Common hybrid architecture:

• ML layer: "I see a face" (computer vision)
• Rules layer: "IF face detected THEN turn toward it and smile (LED pattern)"
• Safety layer: "IF battery low THEN override all behaviors and return to dock"

Real example - Face-following robot:

• Raspberry Pi: Runs OpenCV face detection (ML)
• Arduino: Receives "face at position X,Y" and uses rules to control motors
• Result: ML does what it's good at (seeing), rules do what they're good at (reliable motor control)

Advantage: ML handles perception complexity, rules ensure predictable/safe behavior

Choose RULES when:

• Environment is predictable
• You can describe all situations in if/then statements
• Using simple sensors (distance, light, touch)
• Working with Arduino-level hardware
• You're a beginner learning robotics

Choose LEARNING when:

• Using camera/vision and need to recognize objects/faces/gestures
• Too many possible situations to write rules for
• Need to interpret natural human input (speech, gestures)
• Robot should adapt behavior based on experience
• Have access to Raspberry Pi or better computing

Start with rules, add learning only when necessary. Many successful robots never need ML.

What it is: Smart camera module designed specifically for robotics, works directly with Arduino

Price: $60 (Pixy2 camera from Charmed Labs)

Key capabilities:

• Color blob tracking: "Follow the red ball" - track up to 7 color signatures
• Line following: Built-in line tracking mode for maze navigation
• No Raspberry Pi needed: Works directly with Arduino (sends X,Y coordinates)
• Fast: 60 frames/second tracking

Example projects:

• Ball-following robot (tracks colored ball)
• Color-sorting machine
• Line-following maze solver
• Pet-like robot that follows colored toy

Perfect for: Beginners who want vision without learning Python or ML

What it is: HD camera module for Raspberry Pi, enables full OpenCV capabilities

Price: $15-30 (Camera Module v2 or HQ camera)

Requirements: Raspberry Pi 3/4/5 ($35-80), Python programming

Key capabilities with OpenCV:

• Face detection: Pre-trained Haar Cascade models (built into OpenCV)
• Object detection: Use pre-trained models (YOLO, MobileNet)
• Motion detection: Track movement between frames
• QR code reading: Navigate using QR waypoints
• Color filtering: More sophisticated than Pixy2

Example projects:

• Face-following robot
• Security camera with person detection
• Object-finding robot ("where's my coffee mug?")

Learning curve: Moderate - requires Python and basic OpenCV understanding

What it is: Tiny camera module with WiFi, can stream video and do basic image processing

Price: $10-15 (complete module)

Key capabilities:

• Wireless streaming: View robot's perspective on phone/computer
• Basic vision: Face detection available in Arduino libraries
• IoT integration: Send images to cloud services for AI processing
• Low cost: Cheapest way to add camera to robot

Limitations:

• Less powerful than Raspberry Pi
• Simultaneous camera + WiFi can be unstable
• Better for streaming than heavy processing

Best for: Remote-controlled robots where you want to see what robot sees, simple vision tasks, budget projects

What it is: Free web tool to train custom image recognition models without coding

Price: Free (teachablemachine.withgoogle.com)

How it works:

• Step 1: Upload photos of objects you want robot to recognize (20-50 per category)
• Step 2: Train model in browser (takes 2-5 minutes)
• Step 3: Export as TensorFlow Lite model for Raspberry Pi
• Step 4: Robot can now recognize those objects

Example use cases:

• Train robot to recognize your face vs others
• Recognize hand gestures for control
• Identify specific objects ("find my red mug")
• Pose detection for interactive art

Perfect for: Custom recognition tasks without ML expertise. Deploy to Raspberry Pi.

What it is: Platform for building ML models that run on microcontrollers and edge devices

Price: Free for developers, paid plans for commercial use

Key capabilities:

• Vision + audio: Train models for image AND sound recognition
• Optimized: Models run fast on limited hardware (Arduino Nano 33, ESP32)
• End-to-end: Data collection → training → deployment in one platform
• Pre-built projects: Templates for common robotics tasks

Example projects:

• Gesture-controlled robot (train on your hand gestures)
• Sound-activated behaviors (recognize specific sounds)
• Custom object detection

Best for: Intermediate makers wanting ML without powerful computers. Deploy to Arduino-class devices.

What it is: Small computer optimized for AI/ML workloads, GPU-accelerated

Price: $150-200 (Jetson Nano 4GB, though availability varies)

Key capabilities:

• Real-time object detection: YOLO models at good frame rates
• Multiple cameras: Process several video streams simultaneously
• Deep learning: Run complex neural networks (pose estimation, semantic segmentation)
• CUDA acceleration: Much faster than Raspberry Pi for ML

When you need Jetson over Raspberry Pi:

• Real-time object detection (multiple objects, complex scenes)
• Advanced autonomous navigation
• Multiple simultaneous ML models
• Commercial/professional robotics projects

Trade-offs: More expensive, higher power consumption, steeper learning curve

How it works: Direct sensor-to-action mapping. No memory, no planning.

Structure:

• Sense → Act (immediate response)
• Example: IF obstacle THEN turn right
• No internal state or memory
• Always responds the same way to same stimulus

Pros: Simple to program, fast response, predictable, reliable

Cons: Can get stuck in loops, no learning, no context awareness

Best for:

• Line-following robots
• Light-seeking behaviors
• Simple obstacle avoidance
• Beginner projects

Arduino example: 10-20 lines of if/then statements in loop()

How it works: Robot has different "modes" and responds differently based on current mode

Structure:

• States: SEARCHING, FOLLOWING, AVOIDING, RETURNING
• Transitions: Rules for switching states
• Same sensor input → different action depending on state

Example - Ball-fetching robot:

• SEARCHING state: Spin slowly, look for colored ball
• APPROACHING state: Ball detected → move toward it
• GRABBING state: Close to ball → activate gripper
• RETURNING state: Ball grabbed → navigate back to start

Best for: Multi-step tasks, pet-like robots with moods, robots that switch between behaviors

Implementation: Switch statement or enum-based state variable in code

How it works: Multiple behavior layers running simultaneously, higher priority behaviors override lower ones

Structure (from high to low priority):

• Layer 3 (highest): Emergency stop (obstacle very close)
• Layer 2: Navigate toward goal
• Layer 1: Wander randomly (default behavior)

How layers interact:

• All layers run simultaneously
• Higher priority layers can override/suppress lower ones
• If high-priority layer doesn't activate, lower ones take over

Example - Autonomous explorer:

• Normally: Wanders exploring (Layer 1)
• Sees interesting object: Approaches it (Layer 2 activates)
• Detects cliff: Emergency stop (Layer 3 overrides everything)

Best for: Robots needing robust real-world behavior, autonomous navigation, combining multiple objectives

How it works: Decision-making structured as tree of behaviors, borrowed from video game AI

Structure:

• Root: Overall goal
• Branches: Decision points (sequences, selectors, conditions)
• Leaves: Actual actions (move, grab, turn, etc.)

Example - Security robot patrol:

• Sequence: Check battery → Is low? → Return to dock
• Selector: Intruder detected? → Investigate OR Continue patrol
• Actions: Move to waypoint, Take photo, Sound alarm

Advantages:

• Very modular - easy to add/remove behaviors
• Visual - can draw tree diagrams
• Reusable - share subtrees between projects

Best for: Complex autonomous behaviors, game-like AI, robots with multiple goals/priorities

Tools: Behavior Tree libraries available for Python (py_trees), C++ (BehaviorTree.CPP)

Principle: When anything goes wrong, robot enters predefined safe state

Safe state behaviors:

• Stop all motors: Don't continue moving blindly
• Visual/audio alert: Flash LED, beep to indicate problem
• Request help: Send notification if networked
• Preserve data: Log sensor readings before shutdown

Example triggers for safe state:

• Battery below 20%
• Sensor returns impossible values (indicates failure)
• Stuck in same position for 30 seconds
• Lost connection to controller
• Timeout: No progress toward goal after X seconds

Implementation: Watchdog timer that resets to safe state if main loop hangs, sanity checks on all sensor data

Principle: Robot continues operating with reduced capability when non-critical systems fail

Capability hierarchy (from critical to optional):

• Critical: Basic motor control, collision avoidance - without these, stop
• Important: Main sensors for task - operate in simpler mode if they fail
• Nice-to-have: LED displays, sounds, WiFi - disable if they fail but continue operating

Example - Vacuum robot:

• Camera fails: Switch to "bump and turn" mode (still cleans, less efficiently)
• One wheel encoder fails: Navigate using remaining sensors, move more slowly
• WiFi drops: Continue cleaning on schedule, report status when reconnected
• Cliff sensor fails: Stop completely (safety-critical)

Design approach: Define multiple operation modes with different sensor/capability requirements

Principle: Validate sensor readings before using them for decisions

Common sensor validation techniques:

• Range checking: Is value within physically possible range?
• Rate limiting: Did value change too quickly? (indicates glitch)
• Multiple readings: Take 3-5 readings, use median or average
• Sensor fusion: Cross-check with other sensors (does camera agree with distance sensor?)
• Timeout detection: Is sensor still responding? Not frozen?

Example validation code pattern:

• Read ultrasonic sensor
• IF reading < 2cm OR > 400cm THEN invalid (out of sensor range)
• IF changed by > 100cm in 0.1 sec THEN likely glitch, ignore
• ELSE use reading

Bad sensor behavior: Dirty sensors, electrical noise, physical obstruction. Validation prevents one bad reading from causing crash.

Principle: Detect when robot is stuck and execute recovery behavior

Stuck detection methods:

• Position monitoring: Motors running but position unchanged for 3 seconds
• Current sensing: Motor current high (indicates blocked)
• Goal timeout: Expected to reach goal in 30 sec, hasn't arrived
• Oscillation detection: Robot repeatedly switching between same two positions

Recovery behaviors:

• Backup and retry: Reverse, turn random angle, try again
• Alternative path: Try different approach to goal
• Call for help: Alert user/system after N failed attempts
• Give up gracefully: Mark goal as unreachable, move to next task

Example: Roomba backs up, turns, and tries new direction when bumper triggers repeatedly in short time

Principle: Robot behavior adapts based on remaining battery charge

Battery-aware behavior tiers:

• 100-40%: Normal operation, all features enabled
• 40-20%: Reduced features (dim LEDs, disable non-critical sensors, slower movement)
• 20-10%: Return to dock/charging station, minimal operation
• Below 10%: Emergency mode - preserve position data, safe shutdown

Implementation:

• Voltage divider circuit to monitor battery ($2 in parts)
• Check battery level every minute
• Display battery status via LED color
• Warn user before auto-shutdown

Auto-docking: Advanced robots (Roomba, Astro) navigate back to charging dock when battery low - requires vision or beacon sensors

Principle: Robot has defined behavior when it loses contact with controller/network

Timeout-based failsafes:

• Heartbeat system: Controller sends signal every 500ms
• IF no signal for 2 seconds: Assume connection lost
• Then: Stop motors, flash warning LED, attempt to reconnect

Example behaviors on disconnection:

• RC robot: Stop immediately (user loses control)
• Semi-autonomous: Continue current task, return to start when done
• Security robot: Continue patrol route, log "comms lost" event
• Delivery robot: Stop, wait for reconnection or manual retrieval

Safety consideration: Never have robot continue full-speed movement without connection unless that's explicitly designed behavior

Status indication: Different LED patterns for "normal operation" vs "autonomous after disconnect"