Intelligent Robots Seminar · Middleware for robotic application - MIRA Designed for real world...

Intelligent Robots Seminar

Topic:Robotics Software Architectures

MIRA, Jadex, Player / Stage

11/23/2015 1Seyyed Morteza Haghshenas– M.Sc. IAS

Supervisor: Lasse Einig

Outline

1. Background

2. Why a Middleware for robotics?

3. Middleware for robotic application – MIRA

4. Jadex

5. Player / Stage

6. Comparisons

7. Conclusion

8. References

11/23/2015 Seyyed Morteza Haghshenas– M.Sc. IAS 2

Background

Robot functional architecture

system's control and data flows, data sources , data stores ,

data processing and data sinks (e.g. the actuators)

Robot component architecture

software structured in components

dependencies

communication

quality of service

Robot runtime architecture

Software components mapped onto processes


Definition of Software Architecture

Description of the subsystems

Components of a software system

Relationship between the components

Specified in different views to show functional and non-functional

properties of the system


Why a Middleware for robotics?

The Middlewear idea

Providing computational layer

A bridge between application and the low level details

It is not set of APIs or Library

Issuing the developing real robot

Cooperating between software and hardware

Architectural differences in robotic systems

Software usability and modularity


Software Architecture in Practice (2nd Edition) Lens Bass, Paul Clemens, Rick Kazman

Robotic Applications


MIRA

Player / Stage

Middleware for robotic application- MIRA


https://en.wikipedia.org/wiki/Middleware_for_Robotic_Applications

Middleware for robotic application- MIRA

Designed for real world applications, teaching and research

Crossed-platform and opensource framework written in C++

Interoperable with other languages i.e. Java, Python and etc.

Comminucation mechanism

RPC: Remote Procedure Calls

Message passing


MIRA Software Modules

Having one or more software module (unit) in each process

Placing units with other units in every process at run time without

coding

Supporting multi threading and data synchronization


MIRA, Middleware for Robotic Applications, IEEE/RSJ International Conference on Intelligent Robots and Systems, October 7-12, 2012. Vilamoura, Algarve, Portugal

Message Passing


MIRA, Middleware for Robotic Applications, IEEE/RSJ International Conference on Intelligent Robots and Systems, October 7-12, 2012. Vilamoura, Algarve, Portugal

Serialization and Reflection

Reflection

Retrive information on the structure of program at run-time

Make a run-time query of the names and type of variables,

classes, methods, etc.

Serialization

Process of converting data structure or objects to a sequence of

bits

Parameter tuning


Design Goals of using MIRA

High performance and low latency

Easy to learn and use

High usability

Foolproof

Robust and reliable

Reflection

Serialization


BDI Abstraction

Deciding on which goals to achieve and how to achieve them

Beliefes: The Information and agent has about its surroundings

Desires: The things that an agent would like to see achieved

Intentions: The desires that an agent is working on; also

involves a deeper personal commitment

Example:

Beliefe: My students are unhappy

Desire: I want to make my students happy

Intention: I will buy 22 ʺ LCD for each of them!


Requirements for BDI Architecture

A BDI architecture addresses how beliefes, desires and intentions

are represented, updated, and proceed

In BDI architecture an agent should (Bratman et al.1987):

Monitor its plans when it changes its believes,

Check compatibility with prior plans (intentions)

Propose new plans when environments changes

The processes should be performed in timely fashion (Bratman et

al.1987)


What is Jadex?

Is a Agent-based computing with a BDI reasoning engine model

Integrates agent theories with object-orientation and XML descriptions

Object-oriented represent of BDI concept

Explicit representation of goals allows reasoning about (manipulaton of)

goals

Jadex is based on JADE platform


What is Jadex?

11/23/2015 Seyyed Morteza Haghshenas– M.Sc. IAS 16http://jade.tilab.com

Jadex Abstracts Agent Architecture

11/23/2015 Seyyed Morteza Haghshenas– M.Sc. IAS 17Agent-based computing, Jadex, Maciej Gawinecki, 2014, IEEE/ International conference on intelligent robotics

Beliefs

Belief base contains the knowledge of an agent

Beliefs : (single facts stored as Java objects)

Beliefsets (sets of facts as Java objects)

object-oriented representation

No support for logical reasoning

Advantages of storing information as facts

Central place for knowledge (accessible to all plans)

Allows queries over agent‘s beliefs

Allows monitoring of beliefs and conditions (e.g. to trigger

events / goals)




Goals (desires)

Generic goal types

Perform (some action)

Achieve (a specified world state)

Query (some information)

Maintain (reestablish a specified world state whenever violated)

Goals are strongly typed with

Name, type, parameters

BDI-flags enable non-default goal-processing

Goal creation/deletion possibilities

Initial goals for agents

Goal creation/drop conditions for all goal kinds

Top-level / sub goals from within plans




Plans (Intentions)

Represent procedural knowledge

Means for goal achievement and reacting to events

Agent has library of pre-defined plans

Execution

Realization of a plan

Plan head specified in ADF (Application Development

Framework)

Plan body coded in pure Java

Assigning plans to goals/events

Plan head indicates ability to handle goals/events

Plan context / precondition refines set of applicable plans




Events

Three types of events

Message event denotes arrival/sending messages

Goal event denotes a new goal to be processed or that the state of

an existing goal is changed

Internal event

Time out

Execute Plan

Condition Triggered


Jadex in Summary

Objective

Supporting the construction of open multi agent systems by making

use of mentalistic notions

Supports easy agent construction with XML-based agent description

and procedural plans in Java

Supports reusability through the capability concept

BDI-Viewer allows to observe and modify the internal state

The BDI-Introspector allows to control the agent

The Logger agent collects log-outputs of any agents


Player Server: an interface for communicating with a robot‘s

resources(sensors and actuators) over an IP network

Player is a network server for robot control

Runs on robot and on PC – Linux, Solaris OS

Client program talks to Player over a TCP socket

Modular architecture makes it easy to support new hardware

Player allows multiple devices to present the same interface

11/23/2015 Seyyed Morteza Haghshenas– M.Sc.. IAS 26

What is Player / Stage?


Player Architecture

Physical Device DO

Physical Device DN

Device DO Command

Buffer

Device DO Data Buffer

Device DN Command

Buffer

Device DN Data Buffer

Device DO Thread

Device DN Thread

Client CO Writer Thread

Client DN Reader Thread

Client CO Reader Thread

Client DN Writer Thread

Client CO Program

Client CN Program

Device Specific Connection e.g. Serial line

TCP Connection

Shared Global Address Area

Commands

Data

Commands

Data

Player/Stage – Player Driver Implementation for ESRP Journal – By Bue Petersen and Jonas Fonseca, 2013


Key concepts in Player

Interface

Player Driver

OS

Stage Driver

Lib stage plugin

Hide hardware detailsComply with defined interfaces

Player runs on OS

Communication with Hardware

Sensor/robot hardware connectedthrough e.g.. Serial port, USB etc.

Device definition

Player/Stage – Player Driver Implementation for ESRP Journal – By Bue Petersen and Jonas Fonseca, 2013


Key Architectural Concepts

1. Interface:

Define the syntax of how to issue commands to actuators and

how to read inputs from sensors through messages

2. Driver:

software that talks with the actual hardware

translates its I/O to conform to relevant interface

Virtual Drivers – special purpose functionality

3. Device:

Top most abstraction in Player for the hardware

Used through a fully-qualified device address

Player is a queue based message passing system

Message Types

Data Messages - used by drivers to publish sensor readings

plus changes in device state, such as motor stalls.

Command Messages – sent by clients ordering driver to

change stateof a specific device it controls

Configuration messages – provide a way for clients to

configure device properties say poses of individual sensors


Message Passing System

Advantages of Player

Supports a wide range of devices like lasers, sonars, camera etc

Programs written for the simulated environment can work on the actual robot

Sensor models and odometry are the same as those used in actual robot

Open source, supports a number of programming languages, windows

Virtual drivers allow for error correction in hardware

Disadvantages

Latency in client / server model

Interface / driver model


Player / Stage in Summary


Survey of the examined Middleware

Conclusion Mira, Jadex and player / stage are relatively good tools for development of Robot

Software

Mira

High performance (Low latency time and low CPU usage)

Fully decentralize

Reliable architecture

Migration of unit at run-time

Message-based communication

Jadex:

Powerful and flexible security mechanism

Allows for the construction of rational agents


Conclusion

Supports an explicit and declarative representation of goals

In testing phase supplying a debugger and a logger agent (usability)

Player / Stage

The most popular robot software systems outside of industrial robots

Flexible communication architecture

Easy to use

Abstracts higher level components from the actual hardware (robot/sensors)

Centralized parameter handling

Logged everything transparency


References

Software Architecture in Practice (2nd Edition) – Lens Bass, Paul Clemens, Rick

Kazman

MIRA - Middleware for Robotic Applications, 2012 IEEE/RSJ International

Conference on intelligent Robots and Systems, October 7-12, 2012. Vilamoura,

Algarve, Portugal

Agent-based computing, Jadex, Maciej Gawinecki, 2014, IEEE/ International

conference on intelligent robotics

H.-M. Gross, H.-J. Böhme, C. Schröter, S. Müller, A. König, E. Einhorn, C.

Martin, M. Merten, and A. Bley, “Interactive Shopping Guide Robots in Everyday

Use - Final Implementation and Experiences from Long-term Field Trials,” in Proc.

IEEE/RJS International Conference on Intelligent Robots and Systems (IROS), pp.

2005–2012, 2009.


References

Player/Stage – Player Driver Implementation for ESRP Journal – By Bue Petersen

and Jonas Fonseca, 2013

ROS: an open-source Robot Operating System - Morgan Quigley, Brian Gerkey,

Ken Conley, Josh Faust ,Tully Foote, Jeremy Leibs, Eric Berger, Rob Wheeler,

Andrew N.

Journal on Three Layer Architectures – Erann Gat Jet Propulsion Laboratory-

California Inst. Of Technology

Journal: On devise abstractions for portable, re-usable robot code - Richard T.

Vaughan, Brian P. Gerkey, Andrew Howard (University of Southern California,)

A. Elkady and T. M. Sobh, “Robotics Middleware: A Comprehensive Literature

Survey and Attribute-Based Bibliography,” Journal of Robotics, 2012


Date post:	23-Jun-2020
Category:	Documents
Upload:	others
View:	7 times
Download:	0 times

Intelligent Robots Seminar · Middleware for robotic application - MIRA Designed for real world...

Documents