The development of software applications for robotics is a challenging task for engineers due to the inherent parallelism of the code and the multitude of flexible factors that must be considered. Robotic assembly, a specific type of robotic application, involves the construction of pre-determined products using designated pieces. This further complicates the engineering task, as not only the robots must be considered but also the construction materials and the product itself. While several specialized solutions for robotic assembly exist, they are typically handcrafted and are tightly bound to the robots and materials they were designed for. Thus, it is hard for these solutions to be extended to respond to changes and newly added modules. This work proposes a model-driven approach to robotic assembly supporting diverse domains that can accommodate the seamless integration of robots. Relational reference attribute grammars are used for both metamodels and runtime models. To assess the feasibility and effectiveness of our proposed approach, we conducted a case study based on an industrial research project.

Teaching heterogeneous robotic cells is difficult and time-consuming. We present a context-aware robot teaching solution based on an open-source framework that decouples the task instruction from the task execution to simplify the teaching workflow significantly. To demonstrate the advantages of the solution, a human operator uses a VR headset and controllers to teach a virtual robot to perform a task, e.g., pick-and-place in a virtual world. The task is automatically adapted to different settings of operation cells and executed by physical robots located at different geographical locations.

Robotic systems compute data from multiple sensors to perform several actions (e.g., path planning, object detection). FPGA - based architectures for such systems may consist of several accelerators to process compute-intensive algorithms. Designing and implementing such complex systems tends to be an arduous task. This work proposes a modeling approach to generate architectures for such applications, compliant with existing robotics middlewares (e.g., ROS, ROS2). The challenge is to have a compact, yet expressive description of the system with just enough information to generate all required components and to integrate existing algorithms. This system model must be generalizable, so it is not application-dependent, and it must exploit the benefits of FPGAs over software solutions. Previous work mainly focused on individual accelerators rather than all components involved in a system and their interactions. The proposed approach exploits the advantages of model-driven engineering and model-based code generation to produce all components, i.e., message converters acting as middleware interfaces and wrappers to integrate algorithms. Data type and data flow analysis are performed to derive the necessary information to generate the components and their connections. Solutions to several identified challenges for generating entire systems from such models are evaluated using four different use cases.

Even though model-driven engineering reduces complexity during the development of self-adaptive systems and [email protected] enables using them during runtime, connecting models to different external systems still involves manual work. Those connections are essential to the complete system, as they enable external systems to react to changes in the internal model and vice versa. In our case, the model is based on Relational Reference Attribute Grammars, an extension of Attribute Grammars to enable conceptual models at runtime while retaining their benefits of modular specification and an incremental evaluation scheme. We present an approach to enable concise specification of the causal connection and needed transformations to match required formats or semantics. To show its applicability, a case study showing the coordination of multiple industrial robot arms using models is presented. We show that using our approach, connections can be specified more concisely while maintaining the same efficiency as hand-written code. The artefact comprising all source code and an executable version of the case studies is available at https://doi.org/10.5281/zenodo.7009758.

Just like current software systems, models are characterised by increasing complexity and rate of change. Yet, these models only become useful if they can be continuously evaluated and validated. To achieve sufficiently low response times for large models, incremental analysis is required. Reference Attribute Grammars (RAGs) offer mechanisms to perform an incremental analysis efficiently using dynamic dependency tracking. However, not all features used in conceptual modelling are directly available in RAGs. In particular, support for non-containment model relations is only available through manual implementation. We present an approach to directly model uni- and bidirectional non-containment relations in RAGs and provide efficient means for navigating and editing them. This approach is evaluated using a scalable benchmark for incremental model editing and the JastAdd RAG system. Our work demonstrates the suitability of RAGs for validating complex and continuously changing models of current software systems.