Robotics Ontology

From Bespoke Robot Society
Revision as of 16:09, 11 October 2025 by John (talk | contribs) (Created page with "= How BRS Organizes Robotics Knowledge = The Bespoke Robot Society uses a specific framework to organize robotics knowledge. We call it the '''ABCs of Robotics''': * '''A'''ctivities - What do you want to happen? (The real-world task) * '''B'''ehaviors - What does the robot need to do to accomplish its part? (The algorithms) * '''C'''apabilities - What hardware upgrades enable the robot to exhibit the behavior and participate in the activity? This ABC framework helps...")
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search

How BRS Organizes Robotics Knowledge

The Bespoke Robot Society uses a specific framework to organize robotics knowledge. We call it the ABCs of Robotics:

  • Activities - What do you want to happen? (The real-world task)
  • Behaviors - What does the robot need to do to accomplish its part? (The algorithms)
  • Capabilities - What hardware upgrades enable the robot to exhibit the behavior and participate in the activity?

This ABC framework helps you understand the flow from vision to reality: start with an activity, break it down into behaviors, then upgrade your robot with the capabilities needed to make it work. From there, building specific implementations is just a matter of following instructions for your hardware.

This page explains the BRS ontology so you can navigate the wiki effectively.

The Four Layers

BRS organizes robotics into four interconnected layers:

Layer What It Is Example Wiki Namespace
Activities Real-world tasks people expect robots to do "Follow a line on the ground" Activity:
Capabilities Hardware abilities - sensors and actuators "Line sensing" or "Differential drive" Capability:
Behaviors Algorithms and software logic "Line following algorithm" Behavior:
Implementations Specific code for specific robots "SimpleBot line following code" robotname:

Working Backwards: Start With Activities

BRS's philosophy is to start with the end in mind. We work backwards from what you want your robot to DO.

1. Activities: The "Why"

An Activity is something people do with, or expect from, their robot.

Activities are the real-world use cases that justify building a robot. They answer the question: "What should this robot accomplish?"

Examples:

Key insight: Activities are robot-agnostic. Any robot with the required capabilities can perform an activity. This means teaching materials can be reused across different robots!

2. Capabilities: The "What Hardware"

A Capability is a hardware ability - either sensing something or actuating (moving) something.

Each Activity requires one or more Capabilities. For example:

Capabilities come in two types:

  • Sensing Capabilities - Detect the environment (line sensors, distance sensors, cameras)
  • Actuation Capabilities - Move or manipulate (motors, servos, grippers)

Key insight: Capabilities define the "tech tree" for robots. Add a new capability to your robot, and you unlock new activities!

3. Behaviors: The "How"

A Behavior is an algorithm or software pattern that connects sensing to action.

Behaviors are implementation-agnostic descriptions of how robots think and react. They include:

  • Algorithm descriptions
  • Pseudocode
  • Decision logic
  • Control theory

Example: The Behavior:Line Following page describes multiple algorithms:

  • One-sensor: Rotate until line found → drive forward → repeat
  • Two-sensor: Turn toward whichever sensor sees the line
  • Multi-sensor array: Use PID control for smooth tracking

Key insight: Behaviors are language-agnostic and sensor-agnostic. The same behavior can be implemented in MicroPython, C++, or Arduino code, using different sensor modules.

4. Implementations: The "Build It"

An Implementation is robot-specific code and instructions.

Implementation pages provide:

  • Hardware setup instructions
  • Wiring diagrams
  • Complete working code (MicroPython, C++, etc.)
  • Calibration procedures
  • Troubleshooting guides
  • Challenge variations

Example: SimpleBot:Line Following Implementation shows exactly how to wire sensors to a SimpleBot, provides tested MicroPython code, and includes tuning instructions.

Key insight: Implementations are step-by-step "how to build it" guides for specific robot hardware.

The Flow: Activity → Capability → Behavior → Implementation

Here's how the layers connect: 

1. You want to: FOLLOW A LINE (Activity)
                     ↓
2. You need: LINE SENSING + DIFFERENTIAL DRIVE (Capabilities)
                     ↓
3. Algorithm: TWO-SENSOR LINE FOLLOWING (Behavior)
                     ↓
4. Build it: SIMPLEBOT LINE FOLLOWING CODE (Implementation)

Example: Line Following

Let's trace line following through all four layers:

Activity: Activity:Line Following

  • What: Follow arbitrary black tape paths on light surfaces
  • Real-world use: Warehouse AGVs, museum tour guides, automated delivery
  • Required capabilities: Line sensing, movement capability
  • Difficulty: Beginner

Capabilities

  • Capability:Line Sensing - Detect light vs dark surfaces using IR reflectance
    • Common hardware: IR obstacle avoidance modules, QTR sensor arrays
    • Used in: SimpleBot, most line-following robots
  • Capability:Differential Drive - Two independently-controlled wheels
    • How it works: Same speed = forward, different speeds = turn
    • Used in: SimpleBot, educational robots, small rovers

Behavior: Behavior:Line Following

  • Two-sensor algorithm:
    1. If both sensors on white → drive straight
    2. If left sensor on line → turn right
    3. If right sensor on line → turn left
    4. If both on line → intersection (special handling)
  • Tuning parameters: Speed, turn aggression, sensor spacing

Implementation: SimpleBot:Line Following Implementation

  • Mount two IR sensors 3cm apart under chassis
  • Wire to GPIO pins 10 and 11
  • Enable pull-up resistors (sensors are active LOW)
  • Upload provided MicroPython code
  • Calibrate sensor potentiometers
  • Test on black electrical tape on white poster board

Why This Matters

This ontology structure provides several benefits:

Reusability

When a new robot joins BRS, it doesn't need new teaching materials from scratch. If it has Line Sensing and Differential Drive capabilities, the existing Activity and Behavior pages apply directly. Only the Implementation page is robot-specific.

Clear Learning Paths

Beginners can:

  1. Browse Activities to find what interests them
  2. Check if their robot has the required Capabilities (or what they need to add)
  3. Learn the Behavior (algorithm)
  4. Follow the Implementation (step-by-step build)

Advanced users can:

  1. Study Behaviors to understand algorithms
  2. Design new Capabilities to enable new Activities
  3. Contribute Implementations for different robots

Community Contribution

The ontology makes it clear where help is needed:

  • Stub Activity pages - "We want robots to do this, but no one has built it yet"
  • Missing Capabilities - "This sensor/actuator would enable new activities"
  • Behavior variations - "Here's a better algorithm for this task"
  • New Implementations - "I built this on Robot X, here's how"

Current Status

Fully Documented (SimpleBot)

Stub Pages (Community Invitations)

  • Activities: Maze Solving, Room Mapping, Sign Reading, Object Manipulation
  • Capabilities: Bump Sensing, Time-of-Flight, LIDAR, IMU, Camera Vision
  • Behaviors: PID Control, SLAM, Wall Following, Pathfinding

These stubs are invitations! If you add bump sensors to SimpleBot, document it and turn the stub into a full page.

How to Use This Wiki

If You Want to Build Something

  1. Start at Activities - pick what you want your robot to do
  2. Check the required Capabilities - do you have the hardware?
  3. Read the Behaviors page to understand the algorithm
  4. Follow the Implementation guide for your specific robot

If You're Adding to a Robot

  1. Browse Capabilities to see what sensors/actuators are possible
  2. Check which new Activities those capabilities unlock
  3. Add the hardware, write the Implementation, share it!

If You're Designing a New Robot

  1. Decide which Activities you want to support
  2. Identify required Capabilities
  3. Design/select hardware to provide those capabilities
  4. Implement the Behaviors in your robot's code
  5. Document your Implementation pages

See Also

Retrieved from "https://wiki.bespokerobotsociety.org/index.php?title=Robotics_Ontology&oldid=17"