Intelligent Robotics

1
Intelligent Robotics

• Today Robot Control Architectures
• Monday Lab Demonstration

2
Robot Control Architecture
3
Robot Movement, Sensing, Reasoning

• Assessment of your environment and the robots
  goals
• What situations does it need to sense? (sensor
  suite, signal processing) (ECE)
• How does it decide what actions to take? (CS)
• What will it manipulate? How will it move? (ME)

4
What does it take to get an intelligent robot to
do a simple task?
Robot Parts Two Arms, Vision, and Brain The
Brain can communicate with all parts Arms can
take commands as left, right, up, down, forward,
and backward Arms can answer yes/no about whether
they are touching something but cannot
distinguish what they are touching The vision
system can answer any question the brain asks,
but cannot volunteer information. The vision
system can move around to get a better view.
5
Why is this simple task so difficult?

• Coordination is difficult
• Indirect feedback
• Updating knowledge about the environment
• Unexpected events
• Need to re-plan
• Different coordinate systems need to be resolved
• Box-centered and arm-centered

6
Spectrum of AI Robot Control
7
Dealing with the Physical World

• A robot needs to be able to handle its
  environment or the environment must be altered
  and controlled.
• Close World Assumption
• The robot knows everything relevant to performing
  Complete World Model
• no surprises
• Open World Assumption
• The robot does not assume complete knowledge
• The robot must be able to handle unexpected
  events.

8
Deliberative/Hierarchical Robot Control

• Emphasizes Planning

• Robot senses the world, constructs a model
  representation of the world, shuts its eyes,
  creates a plan of action, makes the action, then
  senses the results of the action.

9
Deliberative Good Bad

• Goal Oriented
• Solve problems that need cognitive abilities
• Ability to optimize solution
• Predictable
• Dependence on a world model
• Requires a closed world assumption
• Symbol Grounding Problem
• Frame Problem
• Qualification Problem

10
Reactive/Behavior-Based Control

• Ignores world models
• The world is its own best model
• Tightly couples perceptions to actions
• No intervening abstract representations
• Primitive Behaviors are used as building blocks
• Individual behaviors can be made up of primitive
  behaviors
• Reactive no memory
• Behavior-Based Short Term Memory (STM)

11
Reactive Good Bad

• Works with the Open World Assumption
• Provides a timely response in a dynamic
  environment where the environment is difficult to
  characterize and contains a lot of uncertainty.
• Unpredictable
• Low level intelligence
• Cannot manage tasks that require LTM or planning
• Tasks requiring localization and order dependent
  steps

12
Behavior Coordination

• If multiple behaviors are possible which one does
  the robot do?

13
Where does the overall robot behavior come from?

• No planning, goal is generally not explicit
• Emergent Behavior
• Emergence is the appearance of a novel property
  of a whole system that cannot be explained by
  examining the individual components, for example
  the wetness of water.
• Overall behavior is a result of robots
  interaction with its surroundings and the
  coordination between the individual behaviors.

14
Hybrid Paradigm

• Combines Reactive and Deliberative Control

15
Reactive/Behavior-Based Control Design

• Design Considerations
• What are the primitive behaviors?
• What are the individual behaviors?
• Individual behaviors can be made up of primitive
  and other individual behaviors
• How are behaviors grounded to sensors and
  actuators?
• How are these behaviors effectively coordinated?
• If more than one behavior is appropriate for the
  situation, how does the robot choose which to
  take?

16
Situated Activity Design

• Robot actions are based on the situations in
  which it finds itself
• Robot perception is characterized by recognizing
  what situations it is in and choosing an
  appropriate action

17
Designing a Behavior-Based ControlFinite State
Machine
18
Design of Behaviors represented by a State
Transition Table
q ? K Set of states (behaviors)
s ? S Set of releasers
d Transition function
s State Robot starts in
q ? F Set of terminating states
Trash Pick-up Example
19
Design for robot soccer

• What primitive behaviors would you program?
• What individual behaviors?
• What situations does the robot need to recognize
• If the pass behavior is active and the shoot
  behavior is active, how does it choose?

20
Implementing Behaviors

• Schema knowledge process
• Perceptual Schema interpretation of sensory data
• Motor Schema actions to take.
• Releasers instantiates motor schema

21
Schema for Toad Feeding Behavior
22
Competitive Coordination

• Action Selection Method
• Behaviors compete using an activation level
• The response associated with the behavior with
  the highest activation level wins
• Activation level is determined by attention
  (sensors) and intention (goals)

23
Competitive Coordination

• Suppression Network Method
• Response is determined by a fixed prioritization
  in which a strict behavioral dominance hierarchy
  exists.
• Higher priority behaviors can inhibit or suppress
  lower priority behaviors.

24
Cooperative Coordination

• Behavioral Fusion
• Requires the ability to use concurrently the
  output of more than one behavior at a time

Behavior Fusion via vector summation
25
Competitive Coordination

• Voting Methods democratic arbitration
• Each behavior casts votes for actions and the
  action that receives the most votes wins.

26
Subsumption Architecture

• A suppression network architecture built in
  layers
• Each layer gives the system a set of pre-wired
  behaviors
• Layers reflect a hierarchy of intelligence.
• Lower layers are basic survival functions
  (obstacle avoidance)
• Higher layers are more goal directed (navigation)
• The layers operate asynchronously (Multi-tasking)
• Lower layers can override the output from
  behaviors in the next higher level
• Rank ordering

27
Foraging Example
28
Using Multiple Behaviors requires the Robot to
Multi-task

• Multi-tasking is having more than one computing
  processing run in parallel.
• True parallel processing requires multiple CPUs.
  
• IC functions can be run as processes operating in
  parallel. The processor is actually shared among
  the active processes
• main is always an active process
• Each process, in turn, gets a slice of processing
  time (5ms)
• Each process gets its own default program stack
  of 256bytes
• A process, once started, continues until it has
  received enough processing time to finish (or
  until it is killed by another process)
• Global variables are used for inter-process
  communications

29
IC Functions vs. Processes

• Functions are called sequentially
• Processes can be run simultaneously
• start_process(function-call)
• returns a process-id
• processes halt when function exits or parent
  process exits
• processes can be halted by using
• kill_process(process_id)
• hog_processor() allows a process to take over
  the CPU for an additional 250 milliseconds,
  cancelled only if the process finishes or defers
• defer() causes process to give up the rest of
  its time slice until next time

30
IC Process Example

• use pause.ic
• int done / global variable
• for inter-process communication /
• void main()
• pause()
• done0
• start_process (ao_when_stop())
• start_process (avoidBehavior())
• start_process (cruiseBehavior())
• start_process (collisionBehavior())
• start_process (arbitrate())
• . . . more code . . .
• void ao_when_stop()
• while (stop_button() 0) / wait for stop
  button /
• done1 / signal other
  processes /

31
// Example Behavior Avoid / int avoidCommand
// global variable to indicate when behavior is
active void avoidBehavior() while(1)
if (LIGHT_SENSOR lt averageLight - 3) /
releaser/ // Back away from the border.
avoidCommand COMMAND_STOP
Wait(20) avoidCommand
COMMAND_REVERSE Wait(50) // Turn
left or right for a random duration. if
(Random(1) 0) avoidCommand COMMAND_LEFT
else avoidCommand COMMAND_RIGHT
Wait(Random(200)) avoidCommand
COMMAND_NONE
32
// Example Coordinator function Arbitrator int
motorCommand // global command setting the
motors to the winning behavior motor schema void
arbitrate() while(1) if (cruiseCommand
! COMMAND_NONE) motorCommand cruiseCommand
if (avoidCommand ! COMMAND_NONE)
motorCommand avoidCommand if
(collisionCommand ! COMMAND_NONE) motorCommand
collisionCommand motorControl() //set
actual motor controls to winning behavior
33
// Example function grounding behavior to motor
commands void motorControl() if
(motorCommand COMMAND_FORWARD) fd(1)
fd(3) else if (motorCommand
COMMAND_REVERSE) bk(1) bk(3) else if
(motorCommand COMMAND_LEFT) fd(1)
bk(3) else if (motorCommand
COMMAND_RIGHT) bk(1) fd(3) else if
(motorCommand COMMAND_STOP) brake(1)
brake(3)
34
Localization Navigation
Reading Intro to AI Robotics Chapters 9, 10 ,11