Modeling of Motion Primitive Architectures using Domain-Specific Languages by Dipl.-Ing. Arne Nordmann Dissertation Faculty of Technology Bielefeld University Bielefeld, August 2015 to the most wonderful family one can wish for to the friends and colleages who joined me on this crazy journey they call doing a phd Printed on permanent paper according to ISO 9706. Abstract Many aspects in robotics, and their omnipresent ideal models, animals and humans, are still not understood or explored well enough, for example producing motions of animal- and human-like complexity. To explore the inner workings of systems studying this complexity, the essential concepts of interest need to be made explicit and raised from the code-level to a higher level of abstraction to be able to reason about them. This work introduces a model-driven engineering approach for complex movement control architectures based on motion primitives, which in recent years have been a central development towards adaptive and flexible control of complex and compliant robots. The goal is to realize rich motor skills through the composition of motion primitives. This thesis proposes a design process to analyze the control architectures of representative example systems to identify common abstractions. Identified and formalized concepts can then be used to automate software development of motion primitive architectures through model-driven engineering methods and domain-specific languages. It turns out that the introduced notion of motion primitives implemented as dynamical systems with machine learning capabilities, provide the computational building block for a large class of such control architectures. Building on the identified concepts, a set of modularized domain-specific languages allows the compact specifica- tion of motion primitive architectures. This paves the way for domain experts rather than computing technology specialists to produce systems, which is one of the main goals of this work. The approach and the accompanying model-driven engineering toolchain is evalu- ated in a task of the European Robotics Challenges (EuRoC) and a real world ex- ample of automatic laundry grasping with the KUKA Lightweight Robot IV, where executable source-code is automatically generated from the domain-specific language specification. i Contents List of Figures vii List of Tables ix I. Introduction1 1. Introduction3 1.1. Problem Statement.............................3 1.2. Contribution and Research Questions..................5 1.3. Outline...................................7 II. Conceptual Perspective 11 2. Model-Driven Engineering in Robotics 13 2.1. Model-Driven Engineering......................... 13 2.2. Domain-Specific Languages........................ 16 2.3. State of the Art............................... 19 2.4. Design Processes.............................. 21 2.5. Discussion.................................. 23 3. Motion Primitive Architectures 25 3.1. Motion Primitives............................. 26 3.2. Learning Motion Primitives........................ 27 3.3. Domain Analysis and Related Work................... 28 3.4. Discussion.................................. 34 4. Model-Driven Engineering for Motion Primitive Architectures 37 4.1. Project and Domain Context....................... 37 4.2. Objectives and Requirements....................... 39 4.3. Process................................... 41 4.4. Discussion.................................. 44 iii III. Developer Perspective 45 5. Technology-independent Architecture and Metamodel 47 5.1. Structural Models............................. 48 5.2. Behavioral Models............................. 57 5.3. Algorithmic Models............................ 59 5.4. Discussion.................................. 60 6. Language Modularization and Design 63 6.1. Language Workbenches.......................... 64 6.2. Language Modularization......................... 65 6.3. Language Design.............................. 69 6.4. Transformations.............................. 79 6.5. Discussion.................................. 83 7. Programming Model and Technology Mapping 85 7.1. Programming Model............................ 86 7.2. Technology Mapping............................ 91 7.3. Mock Platforms and Vertical Prototypes................. 93 7.4. Deployment Descriptors.......................... 96 7.5. Discussion.................................. 97 IV. User Perspective 101 8. Toolchain 103 8.1. Integrated Development Environment.................. 103 8.2. Validation.................................. 105 8.3. Component Repository........................... 106 8.4. Code Generation.............................. 106 8.5. Deployment................................. 111 8.6. Discussion.................................. 112 9. Modeling Motion Primitive Architectures 115 9.1. Hypothesis Test Cycle........................... 116 9.2. Discussion.................................. 123 10.Evaluation and Application 125 10.1. Qualitative Evaluation........................... 126 10.2. Quantitative Evaluation.......................... 132 10.3. Discussion.................................. 135 iv V. Conclusion 137 11.Conclusion 139 11.1. Summary.................................. 139 11.2. Outlook................................... 141 References 143 VI. Appendix 155 A. Related References by the Author 157 B. Domain Analysis 159 B.1. Feature Models............................... 159 B.2. Adaptive Module Survey.......................... 163 v List of Figures 1.1. Left hand trajectories generated with a motion primitive........4 1.2. A typical modeling approach with DSLs..................6 1.3. Outline...................................7 2.1. Four levels of modeling, from meta-metamodel to GPL code...... 14 2.2. Language and fragment dependencies of language modularization types. 18 3.1. Example of a motion primitives on the iCub robot............ 27 3.2. Context diagram of motion architectures................. 30 4.1. Proposed design process.......................... 42 5.1. Quadruped robot Oncilla in simulation.................. 48 5.2. Main abstractions and relations of the motion primitive architecture.. 49 5.3. Object diagram of Spaces, Space Types, and Data Types....... 50 5.4. Specializations of Mappings and Transformations............. 51 5.5. Inverse Kinematics Mapping for Foot Position and Leg Joints...... 52 5.6. Composite structure diagram of an Adaptive Module.......... 53 5.7. Adaptive Module lifecycle......................... 54 5.8. Adaptive Module for the walking dynamics............... 55 5.9. Specializations of the Adaptive Component concept........... 56 5.10. Reaching Controller for placement of the left fore foot.......... 57 5.11. Metamodel of the behavioral aspects.................... 58 5.12. Metamodel of the algorithmic aspects................... 59 5.13. Specializations of the Expression concept................. 60 5.14. Reaching dynamics expressed in the algorithmic model......... 61 6.1. Parser-based approaches vs. projectional editing............. 65 6.2. Language modularization and their dependencies............. 66 6.3. Metamodel of the Component DSL.................... 67 6.4. Language composition of the Primitive Coordination DSL........ 68 6.5. Language design aspects in Jetbrains MPS................ 70 6.6. Language structure definition in MPS................... 72 6.7. Language editor definition in MPS..................... 73 6.8. DSL expression of structural motion primitive architecture aspects... 75 6.9. Dynamical System DSL integrated into the Motion Primitive DSL... 75 6.10. Integration of domain concepts with the MPS base language...... 77 6.11. Coordination DSL snippet with Primitive Coordination DSL extensions. 78 vii 6.12. Model-to-model transformations...................... 80 6.13. Transforming an Adaptive Module to a Component........... 82 6.14. Generator rule to map a Coordination DSL state to SCXML...... 83 7.1. Class diagram of the programming model................. 86 7.2. Mapping of a Reaching Controller to Component DSL concepts.... 88 7.3. Domain-specific programming model................... 89 7.4. Technology mapping for the structural aspects.............. 92 7.5. Technology mapping for the behavioral aspects............. 93 7.6. Oncilla roundtrip.............................. 94 7.7. The Dynamical System in the running example replaced by the MVITE. 98 7.8. Levels of modeling in relation to the deployment descriptors...... 99 8.1. Customized, MPS-based IDE themed for the AMARSi project..... 104 8.2. Screenshot of the DSL IDE editor view.................. 105 8.3. Using models from the repository in the DSL IDE............ 107 8.4. Model-to-text transformations....................... 108 8.5. Auto-generated visualization of the coordination of the running example.108 8.6. MSM transformation rule for the Robot Converged condition...... 109 8.7. TextGen rules for C++ main file generation............... 110 8.8. Toolchain and software builds on continuous integration server..... 111 9.1. Hypothesis Test Cycle........................... 117 9.2. Data Type incompatibility solved by adding a suitable Mapping.... 120 9.3. Space annotations of middleware scopes.................. 121 9.4. Space annotations of transport configuration............... 122 10.1. Task 4 of the Shop Floor Logistics and Manipulation task....... 127 10.2. Example State using Middleware Coordination DSL extensions..... 128 10.3. Example State using Primitive Coordination DSL extensions...... 130 10.4. Automated laundry handling