Category Archives: Robotic Software

Designing robotic architectures by coordinating different modules in a data-flow graphical paradigm

Sebastian Buck, Andreas Zell, CS::APEX: A Framework for Algorithm Prototyping and Experimentation with Robotic Systems. Modeling Perception and High Level Robot Control with Activity Flow Graphs, Journal of Intelligent & Robotic Systems (2019) 94:371–387, DOI: 10.1007/s10846-018-0831-7.

Robotic systems differ drastically in their sensory capabilities, their computational power and their designated tasks. For
efficient algorithm development, however, we need to have a common modeling framework that enables us to generalize and
re-use existing solutions. A modular approach, which is coherent across different platforms, also allows faster prototyping
of new systems, given that existing functionality can be reused from already implemented modules. In this paper we develop
a modeling framework based on data flow graphs that achieves the following goal: We first merge synchronous data flow
and reactive programming into hybrid flow graphs, where we explicitly model synchronous and asynchronous data flow.
Then we transfer concepts from finite-state machines to achieve a coherent framework which we call Activity Flow Graphs.
The flow of activity enables us to model high level states directly in the data flow graph. The result is a single computation
graph that can express both perception and high level control aspects of any robotic system. This theoretical foundation is
the core of our open-source software framework CS::APEX, which allows the creation, manipulation and evaluation of
Activity Flow Graphs and enables rapid prototyping and experimentation and can be used with any robot supporting the
Robot Operating System (ROS). We then demonstrate the framework with two high level models for a fetch-and-delivery
robot and a person following robot.

On the use of ubiquous supercomputing for robotics

Leonardo Camargo-Forero, Pablo Royo, Xavier Prats, The ARCHADE: Ubiquitous Supercomputing for robotics. Part I: Philosophy, Robotics and Autonomous Systems, Volume 114, 2019, Pages 187-198 DOI: 10.1016/j.robot.2019.01.006.

In this work, we introduce Ubiquitous Supercomputing for robotics with the objective of opening our imagination to the development of new powerful heterogeneous multi-robot systems able to perform all kind of missions. Supercomputing, also known as High Performance computing (HPC) is the tool that allows us to predict the weather, understand the origins of the universe, create incredibly realistic fantasy movies, send personalized advertisement to millions of users worldwide and much more. Robotics has been mostly absent in its use of HPC but some previous works have lightly flirted with it. With the findings presented in here, we propose a ubiquitous supercomputing ontology, which allows describing systems made up of robots, traditional HPC infrastructures, sensors, actuators and people and exhibiting scalability, user-transparency and ultimately higher computing efficiency. Moreover, we present a technology called The ARCHADE, which facilitates the development, implementation and operation of such systems, and we propose a mechanism to define and automatize missions carried out by ubiquitous supercomputing systems. As a proof of concept, we present a system depicted as Tigers VS Hunters, which illustrates the potential of this technology. The results presented in here are part of a two series work introducing The ARCHADE. This first delivery presents its philosophy and main features. Correspondingly the second part will present a set of use cases and a complete performance benchmark. Supercomputing is part of our lives and it can be found in many research and industrial endeavors. With the ubiquitous supercomputing ontology and The ARCHADE, supercomputing will become part of robotics as well, bringing it therefore everywhere.

A ROS module that improves real-time aspects of network communication among distributed ROS machines, and a nice analysis of wireless network characteristics and limitations

Danilo Tardioli, Ramviyas Parasuraman, Petter Ögren, Pound: A multi-master ROS node for reducing delay and jitter in wireless multi-robot networks, Robotics and Autonomous Systems, Volume 111, 2019, Pages 73-87, DOI: 10.1016/j.robot.2018.10.009.

The Robot Operating System (ROS) is a popular and widely used software framework for building robotics systems. With the growth of its popularity, it has started to be used in multi-robot systems as well. However, the TCP connections that the platform relies on for connecting the so-called ROS nodes presents several issues regarding limited-bandwidth, delays, and jitter, when used in wireless multi-hop networks. In this paper, we present a thorough analysis of the problem and propose a new ROS node called Pound to improve the wireless communication performance by reducing delay and jitter in data exchanges, especially in multi-hop networks. Pound allows the use of multiple ROS masters (roscores), features data compression, and importantly, introduces a priority scheme that allows favoring more important flows over less important ones. We compare Pound to the state-of-the-art solutions through extensive experiments and show that it performs equally well, or better in all the test cases, including a control-over-network example.

High performance robotic computing (HPRC) vs. High performance computing, and its application to multirobot systems

Leonardo Camargo-Forero, Pablo Royo, Xavier Prats, Towards high performance robotic computing, Robotics and Autonomous Systems, Volume 107, 2018, Pages 167-181 DOI: 10.1016/j.robot.2018.05.011.

Embedding a robot with a companion computer is becoming a common practice nowadays. Such computer is installed with an operatingsystem, often a Linux distribution. Moreover, Graphic Processing Units (GPUs) can be embedded on a robot, giving it the capacity of performing complex on-board computing tasks while executing a mission. It seems that a next logical transition, consist of deploying a cluster of computers among embedded computing cards. With this approach, a multi-robot system can be set as a High Performance Computing (HPC) cluster. The advantages of such infrastructure are many, from providing higher computing power up to setting scalable multi-robot systems. While HPC has been always seen as a speeding-up tool, we believe that HPC in the world of robotics can do much more than simply accelerating the execution of complex computing tasks. In this paper, we introduce the novel concept of High Performance Robotic Computing — HPRC, an augmentation of the ideas behind traditional HPC to fit and enhance the world of robotics. As a proof of concept, we introduce novel HPC software developed to control the motion of a set of robots using the standard parallel MPI (Message Passing Interface) library. The parallel motion software includes two operation modes: Parallel motion to specific target and swarm-like behavior. Furthermore, the HPC software is virtually scalable to control any quantity of moving robots, including Unmanned Aerial Vehicles, Unmanned Ground Vehicles, etc.

The security problems of ROS

Bernhard Dieber, Benjamin Breiling, Sebastian Taurer, Severin Kacianka, Stefan Rass, Peter Schartner, Security for the Robot Operating System, Robotics and Autonomous Systems,
Volume 98, 2017, Pages 192-203, DOI: 10.1016/j.robot.2017.09.017.

Future robotic systems will be situated in highly networked environments where they communicate with industrial control systems, cloud services or other systems at remote locations. In this trend of strong digitization of industrial systems (also sometimes referred to as Industry 4.0), cyber attacks are an increasing threat to the integrity of the robotic systems at the core of this new development. It is expected, that the Robot Operating System (ROS) will play an important role in robotics outside of pure research-oriented scenarios. ROS however has significant security issues which need to be addressed before such products should reach mass markets. In this paper we present the most common vulnerabilities of ROS, attack vectors to exploit those and several approaches to secure ROS and similar systems. We show how to secure ROS on an application level and describe a solution which is integrated directly into the ROS core. Our proposed solution has been implemented and tested with recent versions of ROS, and adds security to all communication channels without being invasive to the system kernel itself.

A new robotic middleware that exposes “resources” to the network instead of functionality

Marcus V. D. VelosoJosé Tarcísio C. FilhoGuilherme A. Barreto, SOM4R: a Middleware for Robotic Applications Based on the Resource-Oriented Architecture, Journal of Intelligent & Robotic Systems, Volume 87, Issue 3–4, pp 487–506, DOI: 10.1007/s10846-017-0504-y.

This paper relies on the resource-oriented architecture (ROA) to propose a middleware that shares resources (sensors, actuators and services) of one or more robots through the TCP/IP network, providing greater efficiency in the development of software applications for robotics. The proposed middleware consists of a set of web services that provides access to representational state of resources through simple and high-level interfaces to implement a software architecture for autonomous robots. The benefits of the proposed approach are manifold: i) full abstraction of complexity and heterogeneity of robotic devices through web services and uniform interfaces, ii) scalability and independence of the operating system and programming language, iii) secure control of resources for local or remote applications through the TCP/IP network, iv) the adoption of the Resource Description Framework (RDF), XML language and HTTP protocol, and v) dynamic configuration of the connections between services at runtime. The middleware was developed using the Linux operating system (Ubuntu), with some applications built as proofs of concept for the Android operating system. The architecture specification and the open source implementation of the proposed middleware are detailed in this article, as well as applications for robot remote control via wireless networks, voice command functionality, and obstacle detection and avoidance.

Massive parallelization of POMDPs with a very good state-of-the-art review

Taekhee Lee, Young J. Kim (2015), Massively parallel motion planning algorithms under uncertainty using POMDP , The International Journal of Robotics Research, Vol 35, Issue 8, pp. 928 – 942, DOI: 10.1177/0278364915594856.

We present new parallel algorithms that solve continuous-state partially observable Markov decision process (POMDP) problems using the GPU (gPOMDP) and a hybrid of the GPU and CPU (hPOMDP). We choose the Monte Carlo value iteration (MCVI) method as our base algorithm and parallelize this algorithm using the multi-level parallel formulation of MCVI. For each parallel level, we propose efficient algorithms to utilize the massive data parallelism available on modern GPUs. Our GPU-based method uses the two workload distribution techniques, compute/data interleaving and workload balancing, in order to obtain the maximum parallel performance at the highest level. Here we also present a CPU–GPU hybrid method that takes advantage of both CPU and GPU parallelism in order to solve highly complex POMDP planning problems. The CPU is responsible for data preparation, while the GPU performs Monte Cacrlo simulations; these operations are performed concurrently using the compute/data overlap technique between the CPU and GPU. To the best of the authors’ knowledge, our algorithms are the first parallel algorithms that efficiently execute POMDP in a massively parallel fashion utilizing the GPU or a hybrid of the GPU and CPU. Our algorithms outperform the existing CPU-based algorithm by a factor of 75–99 based on the chosen benchmark.

Model checking for the verification of the correct functionality in the presence of sensor failures of a network of behaviours included in a robotic architecture

Lisa Kiekbusch, Christopher Armbrust, Karsten Berns, Formal verification of behaviour networks including sensor failures, Robotics and Autonomous Systems, Volume 74, Part B, December 2015, Pages 331-339, ISSN 0921-8890, DOI: 10.1016/j.robot.2015.08.002.

The paper deals with the problem of verifying behaviour-based control systems. Although failures in sensor hardware and software can have strong influences on the robot’s operation, they are often neglected in the verification process. Instead, perfect sensing is assumed. Therefore, this paper provides an approach for modelling the sensor chain in a formal way and connecting it to the formal model of the control system. The resulting model can be verified using model checking techniques, which is shown on the examples of the control systems of an autonomous indoor robot and an autonomous off-road robot.

Survey on Model-Driven Software Engineering for real-time embedded systems and robotics

Brugali, D., Model-Driven Software Engineering in Robotics: Models Are Designed to Use the Relevant Things, Thereby Reducing the Complexity and Cost in the Field of Robotics, in Robotics & Automation Magazine, IEEE , vol.22, no.3, pp.155-166, Sept. 2015, DOI: 10.1109/MRA.2015.2452201.

A model is an abstract representation of a real system or phenomenon [1]. The idea of a model is to capture important properties of reality and to eglect irrelevant details. The properties that are relevant and that can be neglected depend on the purpose of creating a model. A model can make a particular system or phenomenon easier to understand, quantify, visualize, simulate, or predict.

Checking the behavior of robotic software (i.e., verification) and embedded sw in general, with a good related work on the issue

Lyons, D.M.; Arkin, R.C.; Shu Jiang; Tsung-Ming Liu; Nirmal, P., Performance Verification for Behavior-Based Robot Missions, Robotics, IEEE Transactions on , vol.31, no.3, pp.619,636, June 2015, DOI: 10.1109/TRO.2015.2418592.

Certain robot missions need to perform predictably in a physical environment that may have significant uncertainty. One approach is to leverage automatic software verification techniques to establish a performance guarantee. The addition of an environment model and uncertainty in both program and environment, however, means that the state space of a model-checking solution to the problem can be prohibitively large. An approach based on behavior-based controllers in a process-algebra framework that avoids state-space combinatorics is presented here. In this approach, verification of the robot program in the uncertain environment is reduced to a filtering problem for a Bayesian network. Validation results are presented for the verification of a multiple-waypoint and an autonomous exploration robot mission.