Geoffrey Biggs

A profile and tool for modelling safety information with design information in SysML

Communication both between development teams and between individual developers is a common source of safety-related faults in safety–critical system design. Communication between experts in different fields can be particularly challenging due to gaps in assumed knowledge, vocabulary and understanding. Faults caused by communication failures must be removed once found, which can be expensive if they are found late in the development process. Aiding communication earlier in development can reduce faults and costs. Modelling languages for design have been shown through practical experience to improve communication through better information presentation and increased information consistency. In this paper, we describe a SysML profile designed for modelling the safety-related concerns of a system. The profile models common safety concepts from safety standards and safety analysis techniques integrated with system design information. We demonstrate that the profile is capable of modelling the concepts through examples. We also show the use of supporting tools to aid the application of the profile through analysis of the model and generation of reports presenting safety information in formats appropriate to the target reader. Through increased traceability and integration, the profile allows for greater consistency between safety information and system design information and can aid in communicating that information to stakeholders.

All the Robots Merely Players: History of Player and Stage Software

When robot researchers talk about robot middle ware, inevitably Player will enter the discussion. This piece of software and its related tools have become one of the most popular software tools in robotics research. Its range of hardware support and the flexibility it offers users, as well as its ease of use and shallow learning curve, have ensured its success.

Modelling and Analysis of a Redundant Mobile Robot Architecture Using AADL

As the complexity of robots deployed in the real world increases, the use of formal specifications in the development of safety-critical robot systems is becoming increasingly important. A formal specification gives confidence in the correctness, completeness, and accuracy of a system design. In this paper, we present a formal specification of a redundant control architecture for a mobile robot in the form of a model. The model is created using the Architecture Analysis and Design Language (AADL). This formal language allows the model to be analysed to prove system properties of interest. In this case, we are interested in proving the response time of the robot to external obstacles and to internal errors. We present the model and the results of these analyses with the goal of proving that the architecture is sufficiently safe for use in a safe robot wheelchair.

Native robot software framework inter-operation

Component-based software is a major recent design trend in robotics. It brings many benefits to system design, implementation, maintenance and architectural flexibility. While previous methods of structuring software led to monolithic robot software incapable of easily using multiple architectures, the component-based approach, combined with some suitable software engineering decisions, opens new possibilities for interaction amongst architectures. Rather than using a single architecture for an entire robot system, we now have the opportunity to use the best architecture for the job in each part of the robot without inefficient wrapping or translation. For example, a real-time architecture for actuator control and a planning-based architecture for intelligence. In this paper, we use the example of a native ROS transport for the OpenRTM-aist architecture to illustrate the benefits of allowing architectures to interact in this way.

A simulation environment for OpenRTM-aist

Unified testing of multiple heterogeneous robotic software components is a challenging problem and many robotic systems rely on vendor-specific tools for testing and evaluation of individual subsystems. The consequence is often the unexpected interactions between components that arise during system integration. OpenRTM-aist is a distributed software framework that standardises the development of robotic systems while encouraging software reuse and improving the efficiency of the system integration process. The problem is the lack of a well-integrated simulation tool that provides a safe, virtual test environment for evaluating OpenRTM-aist components. This paper presents a simulation environment for OpenRTM-aist. As opposed to creating a built-in simulation tool tied to the OpenRTM-aist architecture, we use an existing general purpose robot simulator, namely Gazebo, because of its modular design and framework independent architecture. We show that by creating an interface layer to Gazebo, robotic systems developed using OpenRTM-aist can be tested in Gazebo simulation without modifications to the underlying software code. In addition, we demonstrate the interoperability between OpenRTM-aist component-based robot systems and Player client programs in achieving a global robot task in the same simulation context.

Flexible, adaptable utility components for component-based robot software

Component-based software design is a current trend, both in general software practice and in robot software practice. It brings benefits to the field of robot programming. Component interfaces are fixed at design time and form a contract with other components, guaranteeing functionality. Known interfaces are typically important to reusability. However, in certain cases fixed interfaces can limit the reusability of components. Utility components provide general functionality that is reused a large number of times both within a single software system and between systems. They need to be adapted to the interfaces for each specific use case. This paper presents a set of utility components that can adapt their interfaces to the users needs without any code changes. Dynamic programming language techniques are used to provide the adaptability. The components are a great benefit to the reusability of common utility components, removing a common cause of reinvention.

Rapid data processing pipeline development using OpenRTM-aist

Detecting and understanding the world is an important step for any intelligent system, but also one that often requires significant processing power. This places great emphasis on the creation of efficient but flexible data processing pipelines. In this paper, we discuss the use of OpenRTM-aist and a component-based approach to rapidly create sensor processing pipelines. The sensor pipeline is made up of a series of filtering and processing steps, provided by pre-existing components for each step. We illustrate the techniques with a pipeline for processing point clouds using the PCL library.

Applying regression testing to software for robot hardware interaction

If robots are to be fully accepted in the homes and offices of the world, it is important that they are guaranteed to be reliable and not to cause damage or harm. This requires testing robot systems and the software that comprises them. But testing robot software has always been a difficult process for developers. Issues of repeatability, safety, access to hardware and the general complexity of robot software are encountered. In industrial robotics, these difficulties are mitigated somewhat by the relatively simple, repeatable tasks and the controlled environment. Robotics for real-world environments, on the other hand, face the full challenges of testing. In this paper, we discuss regression testing at a low level of individual software components, particularly those components that are designed to interface with robot hardware. We present a software system for regression testing these components in a fully repeatable fashion as a case study of performing such testing in robotics. The presented system provides an efficient and quick method to monitor changes in the behaviour of software components as they are developed. Developers of robot software can quickly discover undesired changes and correct them.

Implementing a reactive semantics using OpenRTM-aist

The expression of reactive behaviour is a significant and important requirement in robotic software engineering, since robots must cope with a wide range of unpredictable events and environments. However it is important that the semantics for reactive expression can be used across different architectures and languages. The RADAR robot programming language provides architecture- and language-independent semantics for managing the reactive parts of robot software together with the deliberative parts, allowing greater interaction between the two. We evaluate the architecture-independence of RADAR, as an example, by implementing its reactive semantics using the OpenRTM-aist component-based, distributed architecture. Our goal is to evaluate what limitations the choice of implementation environment may place on the capabilities of such an architecture-independent semantics. In our implementation, we aimed to produce a standard OpenRTM-aist system using the RADAR semantics. We have found that the architecture-independent semantics concept works well in the case of RADAR, although some specific improvements are needed for full interaction between deliberative and reactive sections of robotic software.

Coordinating software components in a component-based architecture for robotics

Component-based software is a major design trend in robot software. It brings many benefits to system design, implementation and maintenance. One step in using component-based methods in designing the structure of a robot program is managing the components and the connections between them over time, known as coordination. In this paper we present a framework for coordinating component networks using the OpenRTM-aist software architecture, implemented using the concurrent Erlang language. The framework provides a coordination system that mimics the internal state-change notification system of OpenRTMaist. Rather than being a fixed- structure coordinator, it allows robot developers to implement a coordinator matching the style of coordination they need. This paper shows that Erlang has potential in robotics.