ARGO - A Customized Jason Architecture for Programming Embedded Robotic Agents

 Pantoja, Stabile, Lazarin and Sichman 2016 EMAS@AAMAS 2016, Singapore, 09/05/16 ARGO 1
ARGO: A Customized Jason Architecture for
Programming Embedded Robotic Agents
1. Instituto de Matemática e Estatística (IME), Universidade de São Paulo (USP), Brazil
2. Escola Politécnica (EP), Universidade de São Paulo (USP), Brazil
3. Centro Federal de Educação Tecnológica (CEFET/RJ), Brazil
4. Universidade Federal Fluminense (UFF), Brazil
Laboratório de Técnicas
Inteligentes - LTI
Carlos Eduardo Pantoja 3,4
Márcio Fernando Stabile Junior 1
Nilson Mori Lazarin 3
Jaime Simão Sichman 2,1
III Workshop on Engineering Multi-Agent Systems
EMAS@AAMAS 2016
Singapore
09/05/2016

ARGO
The Argo
by Lorenzo Costa
Argo was the ship
that Jason and
the Argonauts
sailed in the
search of the
golden fleece in
Greek mythology.

Outline
1. Introduction
2. Building Blocks: Jason / Perception Filters / Javino
3. ARGO
4. Case Study
5. Obtained Results
6. Conclusions and Further Work

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

Motivation
MAS
 A robot is a physical
entity, composed by
customized hardware,
sensors and actuators
 How can we program
and control a robot
including reactive and
goal-directed
behaviours? .

BDI model
[http://www.inf.ufrgs.br/prosoft/bdi4jade]

Jason
[Bordini et al. 2007]

Motivation
 Programming robotic agents using Jason has
revealed to be a difficult task
• Bottlenecks can occur
» high cost of processing perceptions
» large intention stack is generated
• Integration with hardware is not implemented
• Hence, the robot may not succeed !

Motivation
 Javino [Lazarin and Pantoja 2015]
• middleware for communication between Java and
microcontrolers (Arduino)
• However, using several sensors may compromise the
robot execution time
 Perception filters [Stabile Jr and Sichman 2015]
• filters are able to improve Jason agent's performance
in a significant way

Motivation
 Instead of taking into account all perceptions ....
MAS

Motivation
 One can filter perceptions!
MAS

Objectives
 ARGO provides a customized Jason
architecture for programming embedded robotic
agents
• Javino + Perception filters
 Layered robot architecture
 Experiments using a ground vehicle platform in
a real-time collision scenario
 Evaluations of filters impact

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

Jason [1]
• AgentSpeak Interpreter [2]
[1] [Bordini et al. 2007] [2] [Rao 1996]

Jason [1]
• AgentSpeak Interpreter [2]
Most time-
consuming
processes
[1] [Bordini et al. 2007] [2] [Rao 1996]

Profiling
86% of total processing time

Profiling
99% of total processing time

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

Perception filters
 [van Oijen and Dignum 2011]
• Integrating agents (2APL, Jadex and Jason) to
computer games;
• Middleware responsible for perception filtering;
• Interest Subscription Manager.
 [Bordeux et al. 1999]
• Extend AGENTlib with a perception mechanism;
• Perception filter types:
» Range filter;
» Field of view filter;
» Type detector filter.

Perception filters
 Example of Jason perceptions
• List of annotated literals
temperature(right,36)
temperature(back,38)
light(left,143)
distance(front,227)
distance(right,30)

Perception filters
 Example of our perception filter specification
<PerceptionFilter>
<filter>
<predicate>temperature</predicate>
</filter>
<filter>
<predicate>light</predicate>
</filter>
<filter>
<predicate>distance</predicate>
<parameter operator="NE" id="0">front</parameter>
</filter>
</PerceptionFilter>
distance(front,227)[source(percept)]

Perception filters
 Example of filter change internal action
• Name of file passed as parameter
+!carry_to(R)
<− ! take (object, R);
.change_filter(search);
−object (r1);
!!search(slots).

Perception filters

Perception filters
 Changes in Agent class
public void buf(List<Literal> percepts) {
if (percepts == null) {
return;
}
int adds = 0;
int dels = 0;
long startTime = qProfiling == null ? 0 : System.nanoTime();
filter(percepts);
Iterator<Literal> perceptsInBB = getBB().getPercepts();
while (perceptsInBB.hasNext()) {
...

Perception filters
 Changes in Agent class
private static void filter(List<Literal> percept) {
if(currentObjective==null){
return;
}
Iterator<Literal> it = percept.iterator();
while (it.hasNext()) {
if (remove(it.next())) {
it.remove();
}
}
}

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

Javino
 Javino is a protocol for exchanging messages:
• between low-level hardware and a high-level
programming language
• double-side library for communication
• provides error detection

Operation modes
 Listen mode
• only from hardware to software
AGENT
send a message in
every loop
get when it
wants

Operation modes
 Request mode
• from software to hardware;
• the hardware answers.
AGENT
request a message
answer with a message

Operation modes
 Send mode
• from software to hardware;
• the hardware executes an action.
AGENT
send a
message
execute a low-
level command

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

 ARGO is:
• a customized architecture for Jason
• employs both Javino middleware and perception
filters
» Javino provides a bridge between the intelligent agent
and the robots sensors and actuators
» Perception filters act blocking specific perceptions in
runtime
 ARGO aims to be a practical architecture for
programming automated embedded agents
using BDI agents
ARGO

 It directly controls the actuators at runtime
 It receives perceptions from the sensors
automatically within a pre-defined time interval
 It enables changing filters at runtime
 It enables changing accessed device at runtime
 ARGO agents may communicate with others
Jason Agents
 It enables to decide when to perceive the real
world at runtime
ARGO overview

ARGO overview

Overview of Robot’s Architecture

Receiving percepts
Sensors capture raw data from
the real world and send them
to the microcontroller
employed.

Receiving percepts
In the firmware layer, raw data
is transformed into perceptions
based on the AOPL chosen.

Receiving percepts
Javino is responsible for
sending the percepts to the
reasoning layer using serial
communication

Agent’s reasoning
The agent is able to reason
with percepts coming directly
from real world and the MAS
can be embedded in single-
board computers (Raspberry,
etc.) or a computer with USB
interface

Executing an action
Agent deliberates and if an
action has to be executed, an
action message using Javino
is sent.

Executing an action
Javino sends the action
message to the microcontroller
connected in the USB port
described in the message.

Executing an action
All possible actuator’s
functions are programmed to
be executed in response to
serial messages coming from
Javino.

Executing an action
The actuator is activated.

Jason’s reasoning cycle with filters

ARGO’s reasoning cycle

Customized architecture

Customized
architecture created to
differentiate Argo
agents from common
Jason’s agents

Javino instance for
each Argo agent.

Returns the ARGO
agent’s Javino
instance.

The serial port from which the agent is
receiving perceptions and executing actions.

Defines if the agent has
to perceive or not the
real world.

A time interval, in
milliseconds, for the next
real world sensing

Function responsible for
returning the perceptions from
the real world if:
i) the perceptions is not
blocked;
ii) the time limit was reached;
iii) the agent is an ARGO agent

Responsible for filtering
perceptions, as stated
before.

 Changes in TransitionSystem class
public boolean reasoningCycle() {
…
ag.buf(this.realWorldPerceptions());
…
}

 New realWorldPerceptions function
public List<Literal> realWorldPerceptions() {
long perceiving = System.nanoTime();
List<Literal> percepts = new ArrayList<Literal>();
if(((perceiving - lastPerceived) < this.limit) || this.blocked)
return null;
lastPerceived = perceiving;
if (this.agArch.getArgo().requestData(this.agArch.getPort(), "getPercepts")) {
String rwPercepts = this.agArch.getArgo().getData();
String perception[] = rwPercepts.split(";");
for (int cont = 0; cont <= perception.length - 1; cont++) {
percepts.add(Literal.parseLiteral(perception[cont]));
}
return percepts;
}

Internal Actions
 ARGO Internal Actions:
• .limit(x)
» defines the sensing interval in milliseconds
• .port(y)
» defines which serial port should be used by the agent
• .percepts(open|block)
» decides whether or not to perceive the real world
• .act(w)
» sends to the hardware an action to be executed by a microcontroller
• .change_filter(filterName)
» defines the filter to constrain perceptions in runtime

Limitations
 Limit of 127 serial ports
• Due to limitation of USB
 Connection to one port at a time
• Avoids competition
• It can be changed at runtime
 Only ARGO agents can control devices
• Common Jason agents do not have access to Javino
 ARGO agents must be atomic
• Cannot create more than one instance of the same agent

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

Case study
• The robot configuration:
• 4 distance sensors
• 4 light sensors
• 4 temperature sensors
• 1 Arduino board
• 1 Arduino 4WD chassis
• Initial distance of 2m from the wall
• The robot moves at constant speed
• The robot should stop before
achieving a specified desired
distance from the wall

Evaluating the experiment
Experimental design guidelines defined by [Jain 1991]
Essential terms:
 Response variable
• Processing time
» from the moment the robot perceives the wall until it stops
• Final distance
» from the position the robot stops to the wall
 Primary Factors
• Desired distance
• Perception interval
• Filter

 Essential terms:
• Levels
» Values that a factor can assume
Factor Levels
Desired distance 40 cm 80 cm 120 cm
Perception Interval 25 ms 35 ms 50 ms
Filter No Filter Front Side Front Distance
• Replications
» Three times for each experiment (81 experiments)

Desired distance
Initial distance
2 m

Filters
 Front side filter
<PerceptionFilter>
<filter>
</filter>
<filter>
</filter>
<filter>
</filter>
</PerceptionFilter>

Filters
 Front distance filter
<PerceptionFilter>
<filter>
</filter>
<filter>
</filter>
<filter>
</filter>
</PerceptionFilter>

 Agent code:

 Agent code:
Set serial port COM8.
Arduino device.

 Agent code:
Set an interval of 25ms
for perceiving the real-
world

 Agent code:
Open the selected port
to start receiving
percepts

 Agent code:
Activates
frontSide filter

 Agent code:
Send a message
to the
microcontroller to
move ahead

 Agent code:
Keep moving
ahead while the
perceived
distance is
greater than the
distance limit

 Agent code:
Stop when it
perceives the
wall

 Agent code:
Some additional
plans

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

0
20
40
60
80
100
120
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Desired Distance 40 Desired Distance 80 Desired Distance 120
FinalDistance
No filter
Front Side
Front Distance
Experiments
In all
experiments,
the robot
collided with
the wall!!!

0
20
40
60
80
100
120
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
FinalDistance
No filter
Front Side
Front Distance
Experiments
In some
experiments,
the robot
didn’t collided
with the wall!!!
But it stopped
closer to wall
compared to
the front
distance filter

0
20
40
60
80
100
120
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
Perception
Interval 20
Perception
Interval 35
Perception
Interval 50
FinalDistance
No filter
Front Side
Front Distance
Experiments
In quite all the
experiments,
the robot
didn’t collided
with the wall!!!

Experiments
 The use of the filter was important for obtaining a better
response time
Factor Variation attributed
Distance Limit (L) 1,415%
Perception Interval (I) 0,165%
Filter (F) 88,965%
Interaction between L and I 0,525%
Interaction between L and F 3,715%
Interaction between I and F 0,265%
Interaction between L and I
and F
1,725%
error 3,285%

Outline
1. Introduction
3. ARGO
4. Case Study
5. Obtained Results

Conclusions
 The main contribution of ARGO is to offer an
open architecture that enables Jason agents to
integrate with hardware and to use perception
filters
• Reduction processing
 It allows an agent to decide in runtime:
• when to start or to stop perceiving
• the interval between each perception
• which filters to use

Further work
 Different filtering methods
 Extending ARGO for multi-robot systems
 Testing ARGO in different domains
 Provide other hardware-side libraries
• PIC16F, Intel and STM32.

References
[Bordini et al. 2007] Bordini, R.H., Hubner, J.F., Wooldridge, M.
Programming Multi-Agent Systems in AgentSpeak Using Jason. John
Wiley & Sons Ltd., 2007.
[Lazarin and Pantoja 2015] Lazarin, N.M., Pantoja, C.E. A Robotic-Agent
Platform For Embedding Software Agents Using Raspberry Pi and Arduino
Boards. In: Proc. 9th Software Agents, Environments and Applications
School (WESAAC 2015), Niterói, RJ, Brazil, 2015.
[Rao 1996] Rao, A.S. AgentSpeak(L): BDI Agents Speak Out in a Logical
Computable Language. In: de Velde, W.V., Perram, J.W. (eds.) Proc. of the
7th European Workshop on Modelling Autonomous Agents in a Multi-
Agent World (MAAMAW 1996). Lecture Notes in Artificial Intelligence, vol.
1038, pp. 42-55. Springer-Verlag, Secaucus. USA, 1996.
[Stabile Jr. and Sichman 2015] Stabile Jr., M.F., Sichman, J.S. Evaluating
Perception Filters In BDI Jason Agents. In: Proc. 4th Brazilian Conference
on Intelligent Systems (BRACIS 2015), Natal, RN, Brazil, 2015.

Acknowledgements

END
THANKS FOR YOUR ATTENTION
pantoja@cefet-rj.br
mstabile@ime.usp.br
nilson.lazarin@cefet-rj.br
jaime.sichman@poli.usp.br

ARGO - A Customized Jason Architecture for Programming Embedded Robotic Agents

Recomendados

Recomendados

Más contenido relacionado

Más de Carlos Eduardo Pantoja

Más de Carlos Eduardo Pantoja (20)

Último

Último (20)

ARGO - A Customized Jason Architecture for Programming Embedded Robotic Agents

Notas del editor