1
CE801: Intelligent Systems and
Robotics
Lecture 5: Behaviour Based Robotics
Prof. Dr. Hani Hagras
Previous Robot Control Methods
2
 The goal was human level intelligence
 Used a divide and conquer approach
Alternative Robot Control Methods
3
 Two alternative methods that could be used are:
Subsumption
 Motor Schema

Subsumption Architectures
4
 Brooks’s views of these methods:
Human level intelligence is clearly very difficult to
implement and is not the only type of intelligence
 Divide and conquer causes AI researchers to get bogged
down in irrelevant sub-problems
 The resulting design lacks robustness
 Each sub-system is required for the robot to function

Brooks’s Reasoning for a New Architecture
5
 Follow the evolutionary path of intelligence
 Start with simple intelligence
 Easier to implement than human intelligence
 After a successful design, extend to higher levels of intelligence
 Robust design as higher intelligence levels can fail but the lower
levels will still work
 After all, there are plenty of examples of successful intelligence in
nature that are much simpler than many AI research areas
The Subsumption Architecture
6
 The Subsumption Architecture is:
 A layering methodology for robot control systems
 A parallel and distributed method for connecting sensors and
actuators in robots
The Subsumption Architecture
7
 Each layer is made up of connected, simple processors:
Augmented Finite State Machines
The Subsumption Architecture
8
 The most important aspect of these FSMs
 Outputs are simple functions of inputs and local
variables
 Inputs can be suppressed and outputs can be inhibited


This function allows higher levels to subsume the function of lower
levels
Lower levels, therefore, still function as they would without the
higher levels
Programming Characteristics of Subsumption
9
 No internal model of the real world because:
 No free communication
 No shared memory
 So, use real world as the model
 “The world is really a rather good model of itself”1
 Very accurate
 Never out of date
 No computation needed to keep model up to date
 Real world used for sub-system communication
 Instead of direct communication, sub-systems just sense the real
world
10
 Subsumption Architecture based on evolutionary path of
intelligence
 Simple sub-systems developed in layers
 Higher levels subsume the actions of lower levels
 Produces robots that are more robust with parallel,
distributed, simple processors
Behaviours in Subsumption
• Each behaviour is represented using an augmented finite state machine(AFSM).
• The AFSM encapsulates a particular behavioural transformation function
.
i
• All layers work on individual goals concurrently and asynchronously.
An Augmented Finite State Machine
Reset
Inhibitor
R
Input
S
Suppresser
Finite State
Machine(FSM)
I
Output
Subsumption Architectures
AFSMs for a simple 3-layered robot (Brooks87)
Back-out-of-Tight
Situations Layer
Lost
Collide
Reset
Go
Wander
S
Sensors
Run Away
Forward
Reverse
Explore Layer
I
Motors
Brakes
I
Avoid-obstacle Layer
Main features:
• Top layer -- enables the robot reverse direction in particular tight
situation where simpler avoidance and exploration
behaviours fail to extricate the robot.
• Middle layer -- permits the robot to move in the absence of obstacles
and cover large area.
• Bottom layer -- either halts or turns away from an obstacle, depending
upon the input from the robot’s infrared proximity
sensors.
Note:
• Each AFSM performs an action and is responsible for its own
perception of the world.
• There is no global memory, bus or clock.
• Each behavioural layer can be mapped onto its own processor.
Coordination in subsumption
Coordination in subsumption has two main mechanisms:
• Inhibition: used to prevent a signal being transmitted along an AFSM
wire from reaching the actuators.
• Suppression: prevents the current signal from being transmitted and
replaces that signal with the suppression message.
Main features:
•
•
•
•
•
•
A priority-based arbitration is enforced.
Communication is restricted: low baud rate & no handshaking.
Message passing is implemented via machine registers.
Inhibition prevents transmission.
Suppression replaces message with suppressing one.
Reset signal restores behaviour to original state.
Behaviour Language in Subsumption
Behaviour Language in Subsumption
• The behaviour language groups multiple processes into behaviours, shown in (a) below.
• The building blocks for specifying a process are condition-action rules, called
whenever clause in the behaviour language, as shown in (b) below.
• There are message passing, suppression and inhibition both between processes within a
behaviour and between behaviours.
1. (whenever (received? Mess)
(output out (+3 mess)))
2. (whenever (delay 0.5)
(ping-sonars)
3. (whenever (< (infrared 3) (meters 1.5))
(output velocity (meters 1.0))
(delay 0.5)
(output halt ‘t))
(a) whenever clause
Defbehaviour base 0
:decls ((heading :init 0)
(halted :monostable 1.0)
(tvel :init $translate-default-velocity)
(rvel :init $rotate-default-velocity)
(base-state :init $halted)
:inputs (stop heading move delta-tv
delta-rv set-tv set-rv)
:output (status)
:processes
((whenever t (update-base-status))
(b) Example for the behaviour language
Subsumption Architectures
MIT Rug Warrior Program
(a) move forward
(b) detect wall & turn
(c) detect wall & turn
(d) detect leg & turn
(e) toward lamp when it is on
(f) seek light again
Subsumption Architectures
void main() /*run simultaneously*/
{ start_process(motor_driver());
start_process(cruise());
start_process(follow());
start_process(avoid());
start_process(escape());
start_process(arbitrate());
}
Motor Schema Architectures
18
 A schema is the basic unit of behaviour from which
complex actions can be constructed.
 It consists of the knowledge of how to act or perceive as
well as the computational process by which it is enacted.
 The concept has been used by psychologists since the
early 1900s
 Developed for robotics by:


Michael Arbib.
Ronald Arkin.
Architecture
19
Architecture
20
 Perceptual Schema are embedded in the Motor
Schemas
 These provide environment information that is
specific to the behaviour
 Motor Schema provides an action vector containing
orientation and magnitude
 This vector describes how the robot should respond
to the external stimuli
Motor Schema Coordination
21
 Usually by Vector Summation
 With normalization (clipping) to prevent out of range values
Schema Design Process
22
1.Characterize the problem domain in terms of motor behaviours
required to achieve the task.
2. Decompose the motor behaviours to the most primitive level.
3. Develop formula to express robot reaction to perceived
environmental events.
4. Conduct simple simulation studies to assess behaviour
performance in the environment.
5. Determine perceptual requirements required to satisfy the inputs
for each motor schema.
6. Design specific perceptual algorithms.
7. Integrate resulting control system onto the robot.
8. Test and evaluate system performance.
9. Iterate and expand as necessary.