Formal Specification and Verification of Autonomous Robotic Systems: A Survey <s> Domain-Specific Languages (DSLs): <s> The authoritative guide to the Eclipse Modeling Framework (EMF)--written by the lead EMF designers! Shows how EMF unifies three important technologies: Java, XML, and UML @BULLET= Provides a comprehensive overview of the EMF classes including a complete quick reference for all the classes and methods in the EMF 1.1 API. Includes examples of many common framework customizations and programming techniques. <s> BIB001 </s> Formal Specification and Verification of Autonomous Robotic Systems: A Survey <s> Domain-Specific Languages (DSLs): <s> We present a new framework optimized for the design, implementation, and testing of control systems for autonomous robots. It is based on a new visual specification language which specifies both control and data flow, and which is suited to be interpreted in real-time. The framework is divided into a comprehensive development and a lightweight run-time environment. The latter is fully integrated with a real-time operating system and permits to reconfigure a control system without compilation at run time. Moreover, communication in distributed systems is supported. An earlier version of the framework has been successfully applied in an autonomous helicopter and an autonomous ground vehicle project. <s> BIB002 </s> Formal Specification and Verification of Autonomous Robotic Systems: A Survey <s> Domain-Specific Languages (DSLs): <s> General-purpose robots can perform a range of useful tasks in human environments; however, programming them to robustly function in all possible environments that they might encounter is unfeasible. Instead, our research aims to develop robots that can be programmed by its end-users in their context of use, so that the robot needs to robustly function in only one particular environment. This requires intuitive ways in which end-users can program their robot. To that end, this paper contributes a flow-based visual programming language, called RoboFlow, that allows programming of generalizable mobile manipulation tasks. RoboFlow is designed to (i) ensure a robust low-level implementation of program procedures on a mobile manipulator, and (ii) restrict the high-level programming as much as possible to avoid user errors while enabling expressive programs that involve branching, looping, and nesting. We present an implementation of RoboFlow on a PR2 mobile manipulator and demonstrate the generalizability and error handling properties of RoboFlow programs on everyday mobile manipulation tasks in human environments. <s> BIB003 </s> Formal Specification and Verification of Autonomous Robotic Systems: A Survey <s> Domain-Specific Languages (DSLs): <s> Safety is a key challenge in robotics, in particular for mobile robots operating in an open and unpredictable environment. To address the safety challenge, various software-based approaches have been proposed, but none of them provide a clearly specified and isolated safety layer. In this paper, we propose that safety-critical concerns regarding the robot software be explicitly declared separately from the main program, in terms of externally observable properties of the software. Concretely, we use a Domain-Specific Language (DSL) to declaratively specify a set of safety-related rules that the software must obey, as well as corresponding corrective actions that trigger when rules are violated. Our DSL, integrated with ROS, is shown to be capable of specifying safety-related constraints, and is experimentally demonstrated to enforce safety behaviour in existing robot software. We believe our approach could be extended to other fields to similarly simplify safety certification. <s> BIB004 </s> Formal Specification and Verification of Autonomous Robotic Systems: A Survey <s> Domain-Specific Languages (DSLs): <s> Programming sophisticated robots such as service robots or humanoids is still a complex endeavor. Although programming robotic applications requires specialist knowledge, a robot software environment should support convenient development while maintaining full flexibility needed when realizing challenging robotics tasks. In addition, several desirable properties should be fulfilled, such as robustness, reusability of existing programs, and skill transfer between robots. In this work, we introduce the ArmarX statechart concept, which is used for describing control and data flow of robot programs. This event-driven statechart approach of ArmarX helps realizing important features such as increased robustness through distributed program execution, convenient programming through graphical user interfaces, and versatility by interweaving dynamic statechart structure with custom user-code. We show that using hierarchical and distributed statecharts increases reusability, allows skill transfer between robots, and hides complexity in robot programming by splitting robot behavior into control flow and functionality. <s> BIB005
An extensive literature survey identified 137 state-of-the-art DSLs for robotics  , the majority of which were for capturing robotics architectures and for use within mature subdomains (e.g., robot motion). Conversely, fewer DSLs were aimed at emerging subdomains (e.g., force control). The majority of surveyed DSLs were designed to describe the basic components of the system at the early stages of development, but very few were suited to application at runtime. The identified DSLs were often defined using Ecore BIB001 meta-models. Related work on providing a robotics-specific Integrated Development Environment (IDE)  aims to integrate the various phases of robotics software development by guiding the user through a standardised development process. The Declarative Robot Safety language (DeRoS) BIB004 is a DSL for describing a robot's safety rules and corresponding corrective actions. Usefully, this provides automatic code generation to integrate these rules with runtime monitoring by generating an ROS safety monitoring node. Graphical Notations: Graphical notations are present and examined throughout the literature. They usually aim to provide an easy-to-use mechanism for designing robotic software that enables communication between engineers from the various distinct disciplines involved in robotics  BIB002 BIB005 . Statecharts  form the basis for several of these graphical notations, such as Ar-marX statecharts BIB005 , which are executable as C++ programs. A similar executable notation is restricted Finite State Machine (rFSM) Statecharts BIB002 , which represent a subset of UML 2 and Statecharts  . Other notations include RoboFlow BIB003 , which adopts the style of flow charts. RoboFlow is specifically designed for engineering robot movement and manipulation tasks.