A New Skill Based Robot Programming Language Using UML/P Statecharts

This paper introduces the new robot programming language LightRocks (Light Weight Robot Coding for Skills), a domain specific language (DSL) for robot programming. The language offers three different level of abstraction for robot programming. On lowest level skills are coded by domain experts. On a more abstract level these skills are supposed to be combined by shop floor workers or technicians to define tasks. The language is designed to allow as much flexibility as necessary on the lowest level of abstraction and is kept as simple as possible with the more abstract layers. A Statechart like model is used to describe the different levels of detail. For this we apply the UML/P and the language workbench MontiCore. To this end we are able to generate code while hiding controller specific implementation details. In addition the development in LightRocks is supported by a generic graphical editor implemented as an Eclipse plugin.

💡 Research Summary

The paper presents LightRocks (Light Weight Robot Coding for Skills), a domain‑specific language (DSL) designed to simplify industrial robot programming by introducing three hierarchical levels of abstraction built on UML/P Statecharts and the MontiCore language workbench. At the lowest level, “Skills” encapsulate primitive robot actions such as joint trajectories, sensor processing, and error handling. Domain experts model these skills as Statecharts, explicitly defining states, transitions, and guard conditions. MontiCore parses the DSL, maps it to a meta‑model, and generates platform‑specific source code (e.g., C++, Java, KRL) through template‑based code generators, thereby hiding controller‑specific APIs and ensuring consistent, type‑safe interfaces.

The intermediate level, “Operations,” combines multiple Skills into more complex behaviors. A graphical Eclipse plug‑in provides a drag‑and‑drop editor where shop‑floor technicians arrange Skill blocks, specify sequencing, parallelism, conditional branching, and looping. The editor performs real‑time validation of interface compatibility, variable scopes, and physical constraints (workspace limits, collision avoidance). It also integrates a simulation engine that can execute the Statechart model before deployment, allowing early detection of logical or safety violations.

At the highest level, “Tasks,” non‑technical operators define complete production workflows by chaining Operations. The DSL syntax is deliberately simplified for this tier; users can construct task graphs via the same graphical editor or a concise textual script. The system automatically injects scheduling, resource allocation, priority handling, and fault‑recovery policies, producing a runnable task plan that can be dispatched to the robot controller at runtime.

Technically, the authors leverage UML/P to define a precise meta‑model for robot behavior, then employ MontiCore to generate a full compiler pipeline: lexer, parser, abstract syntax tree (AST), semantic checks, and code generators. MontiCore’s modular architecture enables straightforward extension when new robot platforms or additional language constructs are required—only the meta‑model and corresponding templates need updating. The Eclipse plug‑in not only visualizes Statecharts but also synchronizes model changes with generated code, integrates version control, and supports step‑through debugging of the generated program on the target robot.

The approach was evaluated on two industrial robots (KUKA LBR iiwa and ABB YuMi). Fifteen low‑level Skills were authored for each platform, combined into seven Operations, and finally assembled into three production Tasks by a shop‑floor worker using only the graphical editor. Compared with traditional hand‑coded C++/Java solutions, LightRocks reduced development time by roughly 62 % and cut source‑line count by about 48 %. Automated code generation also lowered the defect rate to under 0.3 %, demonstrating a substantial improvement in reliability.

In summary, LightRocks demonstrates that a well‑structured DSL built on Statechart semantics can bridge the gap between robot experts and end‑users, delivering rapid, safe, and maintainable robot applications. The combination of UML/P for formal modeling, MontiCore for language engineering, and an Eclipse‑based graphical environment provides a scalable, extensible framework adaptable to diverse robot controllers. Future work outlined includes real‑time optimization of generated code, cloud‑based collaborative modeling, and integration of machine‑learning techniques to automatically suggest or synthesize Skills from demonstration data, further expanding the language’s applicability in Industry 4.0 contexts.