RoSE '18- Proceedings of the 1st International Workshop on Robotics Software Engineering

Full Citation in the ACM Digital Library

Checking consistency of robot software architectures in ROS

Context: The software architecture of complex robot systems is usually divided into components. The software is then the configuration and combination of those components and their connectors. Objective: In the Robot Operating System (ROS), this architectural configuration, the ROS node graph, is partly defined in code and created at run-time. The static information about the architecture in the configuration is limited and checking the consistency at development time is not possible. The full software has to be manually executed to check the consistency and debug configuration errors. Method: We propose an approach and a corresponding tool to analyze ROS nodes and their launch files to check consistency and issue warnings if potential problems are detected. The approach uses both static analysis of the launch files as well as dynamic analysis of individual ROS nodes to reconstruct the node graph without executing the whole launch configuration. The nodes are executed in a sandbox to prevent side effects and enable the integration of the analysis tool, e.g., into automated testing systems. Results: The evaluation on internal and publicly available ROS projects shows that we are able to reconstruct the complete architecture of the system if the nodes implement a common lifecycle. Conclusion: The approach enables ROS developers to avoid creating incompatible architectures and check consistency already at development time. The approach can be extended to also monitor architectural consistency at run time.

A use case in model-based robot development using AADL and ROS

Designing a robotic application is a challenging task. It requires a vertical expertise spanning various fields, starting from hardware and low-level communication to high-level architectural solution for distributed applications. Today a single expert cannot undertake the entire effort of creating a robust and reliable robotic application. The current landscape of robotics middlewares, ROS in primis, does not offer a solution for this problem yet; developers are expected to be both architectural designers and domain experts. In our previous works we used the Architecture Analysis and Description Language to define a model-based approach for robot development, in an effort to separate the competences of software engineers and robotics experts, and to simplify the merge of software artifacts created by the two categories of developers. In this work we present a practical use-case, i.e., an autonomous wheelchair, and how we used a combination of model-based developed and automatic code generation to completely re-design and re-implement an existing architecture originally written by hand.

On the software engineering challenges of applying reactive synthesis to robotics

Reactive synthesis is an automated procedure to obtain a correct-by-construction reactive system from its temporal logic specification. This short paper discusses the software engineering challenges in applying reactive synthesis to robotics, beyond the synthesis algorithms themselves, including the challenge of writing declarative specifications, the challenge of abstraction of data and time, and the challenge of availability of an adequate development process supported by related tools. The identification and description of the challenges are based on our experience in building a development environment for reactive synthesis and applying it to the construction of about 10 different autonomous Lego robots. We describe the challenges using concrete examples from one of the robots built in our lab.

Using physical quantities in robot software models

One of the challenges of modeling any software application that deals with real-world physical systems resides in the correct representation of numerical values and their units. This paper shows how both measurement uncertainty and units can be effectively incorporated into software models, becoming part of their basic type systems, and illustrates this approach in the particular case of a robot language. We show how our approach allows robot modelers to safely represent and manipulate units and measurement uncertainties of the robots and their elements in a natural manner, statically ensuring unit-safe assignments and operations, as well as the propagation of uncertainty in the computations of derived attributes and operations.

Industrial-scale environments with bounded uncertainty: a productivity maximisation challenge

We present an outline of the operating domain for control software in Ocado warehouses, and provide results which suggest that in this well-understood and highly controlled environment, there are limits to the uncertainty which planning and control systems need to consider. More specifically, that planning approaches can be biased towards rapid recovery when something goes wrong, rather than trying to deal with all possible eventualities up-front. Since academic interest has generally focused on complex and highly fault-tolerant up-front planning, we believe this domain and planning approach is fertile ground for further investigation.

Designing control software for robot swarms: software engineering for the development of automatic design methods

Over the past decade, swarm robotics has emerged as a promising engineering discipline. In this paper, we discuss the current research challenges and state-of-the-art in automatic design methods for swarm control software. This subject has recently received increasing attention from the swarm robotics community. We make a contribution towards the debate by proposing two lines of research from a software engineering point of view.

Engineering safety in swarm robotics

Robotics, artificial intelligence, and the Internet-of-Things are driving current research and development for the technology sector. Robotic and multi-robot systems are becoming pervasive and more and more lives rely on their proper functioning in transportation, medical systems, personal robotics, and manufacturing. Assuring the security and safety of these systems is of primary importance to guarantee the real-world applicability of current research, and we argue that it should be an integral part of system design. Current software standards for safety and security for critical systems (e.g. industrial and aerospace) are not directly applicable to the large distributed systems that are envisioned for the near future. In this paper, we propose to address safety and security of swarm robotics systems at the programming language level. We propose to extend the Buzz multi-robot scripting language with constructs and code analysis that allow the verification of safety and security during development. We believe that detecting and correcting issues with what are inherently emergent systems---i.e. where collective behavior might not be immediately apparent from a single robot's code---during development would allow for a more effective advancement of swarm robotics.

Towards code-aware robotic simulation: vision paper

This vision paper explores the potential to dramatically enrich robotic simulations with insights gleaned from program analysis, and promises to be a key tool for future robot system developers to reduce effort and find tricky corner cases. Robotic simulations are a critical, cost-effective tool for developing, testing, and validating robotic software. However, most robotics simulations are intentionally unaware of how the code works. Our approach leverages two recent developments: 1) automatic program analysis that can semantically ground program variables and predicates in physical quantities like distance, velocity, or force; and 2) standardized simulation specifications that identify both what elements are simulated and also how they are simulated. Code-aware robotic simulation could enable robot system developers who increasingly rely on simulation to lower the cost and risk of system development by having access to richer simulation scenarios. We describe the approach using a detailed, step-by-step illustration for C++ using the Robot Operating System (ROS) and the Simulation Description Format (SDFormat), and identify key challenges to realizing this vision.

Towards rapid composition with confidence in robotics software

Robotics software is booming thanks in part to a rich and productive ecosystem around the Robot Operating System. We introduce a military effort to leverage the ROS ecosystem and reduce the challenges in building military robots, called ROS-M. We outline some of the work we have done on the ROS-M initiative, and explain our future directions in analyzing ROS code to balance between rapid adoption and confidence in the component.