Amity School of Engineering &
Technology
Module 3- Session 2- Steps in designing
a reactive behavourial system
Amity School of Engineering &
Technology
Steps in Designing a Reactive Behavioral System
Describe the task
Specification
& Analysis:
Describe the robot ecological
niche
Describe the environment
Describe how the robot should Design
act in response to its environment
Implement & refine each behavior
Implementation
& unit testing
Test each behavior independently
Test behaviors together System
Testing
Amity School of Engineering &
Technology
Define the Scope and Objectives of the System
• Clarify the robot's mission: The first step in designing a
reactive system is to determine what the robot needs to achieve.
For instance, is it meant to navigate an environment, avoid
obstacles, follow a path, or interact with objects? This helps in
identifying the types of behaviors the system will require.
• Set real-time performance expectations: Since the system is
reactive, it needs to be fast and responsive. Specify requirements
like how quickly the robot should react to obstacles, how
accurately it must follow a path, and how it should handle
dynamic changes in the environment (e.g., moving obstacles).
• Example: For a mobile robot tasked with warehouse navigation,
objectives might include avoiding obstacles, finding and picking
up objects, and delivering them to a specific location, all in real-
time.
Amity School of Engineering &
Technology
Analyze the Environment
• Understand sensor inputs: Sensors play a critical role in
reactive systems because they provide real-time data about
the environment. Analyze which sensors are available (e.g.,
infrared, sonar, LIDAR, cameras), their accuracy, range, and
limitations.
• Map the environment: Identify the physical characteristics of
the environment, such as walls, obstacles, paths, or other
dynamic objects that may move (like humans or other robots).
A clear understanding of the environment ensures appropriate
behavioral responses.
• Example: In a cluttered warehouse environment, the robot
might use ultrasonic sensors to detect obstacles and walls,
and vision systems to identify specific objects.
Amity School of Engineering &
Technology
Break Down the Problem into Behaviors
• Decompose complex tasks into simple, modular behaviors:
Reactive systems work best when each behavior is as simple as
possible. Each behavior should address one aspect of the overall
task, with clearly defined triggers and actions.
• Examples of behaviors:
– Obstacle avoidance: Move away from detected obstacles.
– Wall following: Move parallel to a wall while keeping a certain distance.
– Goal seeking: Move toward a predefined target or goal position.
– Object pickup: Detect an object, approach it, and engage a grabbing
mechanism.
– Emergency stop: Cease all motion when an obstacle is too close.
• By breaking down the problem into modular behaviors, you create
a system where individual behaviors handle specific conditions in
the environment.
Amity School of Engineering &
Technology
Design the Behavior Modules
• Each behavior is a separate module (or class in object-
oriented programming terms) that handles a specific
stimulus-response action. Each behavior consists of:
• Input: Sensor data that triggers the behavior (e.g., distance
to an obstacle).
• Processing/Logic: The decision-making part that
determines how the robot will react.
• Output: Actions to be taken, typically commands sent to
the robot's actuators (e.g., motor control signals).
• Each behavior should be designed to respond to specific
sensor inputs and provide outputs to control the robot's
movement or other mechanisms.
Amity School of Engineering &
Technology
Behavior Prioritization and Coordination
• In a reactive system, multiple behaviors may need to
operate simultaneously, and conflicts can arise when
two behaviors are triggered at the same time. For
example, both "Move Forward" and "Avoid Obstacle"
could be active, but the robot must prioritize obstacle
avoidance.
• Subsumption Architecture: A common method for
managing behavior conflicts. In this architecture,
behaviors are organized into layers, with higher-priority
behaviors suppressing or overriding lower-priority
behaviors.
– For example, Emergency Stop (highest priority)
