Safety is important to a robot that is used in a way that can impact on the wellbeing of people. However, understanding and managing the safety information of a robot is not a trivial task. The quantity of this information is large, and it is usually stored in text-based formats. These factors mean that maintaining safety information when it changes is error prone, and understanding it requires manually searching through lengthy reports. In this paper, we demonstrate that a robot's safety information can be stored in a model-based format. We use the SafeML modelling language to model the results of a safety analysis performed on a semi-autonomous wheelchair. We then illustrate and discuss the benefits of storing and managing safety information using a model, both to maintainability of the information and to understanding the safety of the robot.

In order to maintain balance, the motors of an inverted pendulum-style, two-wheeled self-balancing vehicle need to continuously control its wheels. The vehicle is at risk of falling over if any of its motors does not function properly. Some research in this regard has been devoted to gaining redundancy by using more motors geared to a common shaft, but such technique is not effective for a seizing failure. In this paper, we propose a differential redundant mechanism to prevent a seizing failure in such vehicles. This mechanism unifies plural motors using a differential mechanism, and allows redundant motors to operate at different speeds. Therefore, the vehicle can maintain balance even if a motor fails. Furthermore, our mechanism can form a redundant system of two outputs using only three motors. We also propose a controller for this redundant mechanism that does not require changing the control mode when seizing failures occur.

Development of a system is complex, requiring a well-structured process to manage the range of tasks involved and their work products. There are many models and processes available for structured development, including the well-known Waterfall and Agile models. Recent standards for safety-critical system development utilise the V-model, such as the process given in the ISO 26262 standard for functional safety of road vehicles. However, the process clashes with the commonly-expressed desire for greater reuse of development artifacts in robotics. We have experimented with applying a process, the Object-Oriented Systems Engineering Method, to the design of a robotic wheelchair. This paper describes our application of the process to a safety-critical robot, as well as our use of SysML for managing design information and ZipC for code generation and verification. We discuss our experiences, both good and bad, in order to inform other robot developers of what to consider when choosing a process and tools.

The 4C's of software, computation, communication, configuration and coordination, indicate that the deployment and configuration of software components is an important part of using a component-based software system. This applies as much to robotics as anywhere else, where how to easily deploy the complex web of software components that make up a complete robot system is a well-known problem. We have developed an experimental tool for the deployment and configuration of components using RT-Middleware. It is based on the supervision tree concept. Components are organised into a hierarchy of sub-systems and managed in these groups. The use of a supervision tree ensures that dependencies between components are managed when errors occur, and that errors will propagate up the tree to a supervisor that is capable of handling them.

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 user's 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.

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.

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.

Within the larger task of renovating an office building, there are many repetitive tasks that are suitable for automation. With the decreasing availability of skilled labour and increasing emphasis on reuse of materials, there is an opportunity to introduce robots that can replace labour for the simpler tasks. This paper describes a robot to perform the task of removing tile screws from suspended ceiling beams. The robot uses a specially-designed tool mounted at the end of an arm. This tool removes screws by turning them between two rollers. The tool is moved down the beam in a single motion, allowing it to remove many screws fast with little operator interaction. RT-Middleware is used as the implementation architecture, which facilitated development by simplifying testing of individual components.

A key part of programming a robotic system is specifying the responses to events that the robot may encounter. This is provided by a new language, RADAR. This paper proposes evaluating robot programming systems work by: a formalisation of the semantics, an evaluation in terms of criteria that determine a languagepsilas suitability for programming, and a small user study to test the readability of programs written using the semantics. The evaluation of the reactivity semantics found in the RADAR language shows clear benefits for programmers.

A key part of programming a robotic system is specifying the responses to events that the robot may encounter. Existing methods of programming responses include event loops, reactive languages and hybrid architectures, none of which meet the specific needs of mobile robot programming. This work presents a design for new semantics for specifying reactivity in mobile robot programs, one that allows for effective specification of reactive behaviour within procedural robot programs. An initial evaluation version is implemented in Python. Events and responses are supported as program objects, and are connected together by new statements. Programmers specify connections between events and responses anywhere within the program code, so connections can easily be changed in response to changes in program and robot state