Robotic systems often operate in dynamic and uncertain environments, demanding reliable run time behavior of their increasingly challenging functionalities. Self-adaptive systems address this need. The design of robotic systems also introduces challenges as they are inherently multidisciplinary. Our previous work proposed the cross-domain knowledge model (CDKM) as a means to model cross-domain dependencies to maintain a system-level overview. However, this is currently only used to design the system, not when the system is operational. In this study, we explore the possibility to use the CDKM at run time and we examine how it then can support the self-adaptation process of a robotic system. We apply it within monitor, analyze, plan and execute over a shared knowledge (MAPE-K) for the self-adaptation of an automated guided vehicle (AGV) as use case.

The use of robotic applications is rapidly expanding, with robots increasingly operating in unpredictable environments and in close proximity to humans. While traditionally confined to controlled settings, modern robots must operate in unpredictable real-world scenarios, raising the need for the robots to self-adapt to unprecedented situations. Self-adaptive systems, often realized through the MAPE-K loop, are essential for managing these uncertainties. However, MAPE-K is frequently implemented in an ad hoc manner, which is insufficient for developing trustworthy and reliable self-adaptive systems. The lack of a standardized framework complicates the deployment of adaptive robotic applications, making systematic trust integration challenging.We propose a standardized framework that aids robotic engineers in developing and deploying trust-integrated, distributed MAPE-K systems. Our approach explicitly incorporates a Trust component into the MAPE-K loop to enhance the trustworthiness of adaptive robotic applications. We demonstrate our framework in a real-world MAPE-K scenario using a TurtleBot4.

As Machine Learning (ML) models are integrated into complex systems, their role in safety-critical scenarios and human-in-the-loop environments becomes increasingly significant. These scenarios require that the ML model be trustworthy and predictable. However, ML models are often considered black boxes, making them difficult to validate. As a result, ensuring system safety becomes considerably more difficult. In this paper, we propose the validity frame concept to manage the ML lifecycle and improve trust in the model. Within the frame, we capture key factors that influence a ML model’s performance throughout its lifecycle, from data collection and training to model deployment. These factors are explicitly linked back to the model requirements to ensure traceability. We present this approach using a practical case study involving anomaly detection in a Brushless Direct Current (BLDC) motor. This demonstrates how the validity frame enables lifecycle monitoring and informed design decisions. We discuss the viability of this approach, its limitations, and provide ideas for future work.

In the Verification and Validation (V&V) of Cyber-Physical Systems (CPS), engineers typically progress through various X-in-the-Loop (XIL) testing stages: Model-in-the-Loop (MIL), Software-in-the-Loop (SIL), and Processor-in-the-Loop (PIL). At the MIL and SIL stages, the Functional Mock-up Interface (FMI) standard is commonly used to enable co-simulation of models across different tools, but its use in PIL remains limited. We propose an approach to seamlessly integrate PIL into existing FMI-based co-simulation and testing frameworks. To this end, we develop a prototype backend for the UniFMU framework and leverage synchronous clocks introduced in FMI 3.0 to incorporate the actual execution time of the application into the co-simulation. This enables the reuse of existing MIL and SIL setups for PIL, while making the impact of numerical representation and execution time, measured on the target hardware, visible within the co-simulation.

Modern robotic applications frequently employ the MAPE-K (Monitor, Analyze, Plan, Execute, and Knowledge) loop for adaptive behavior. However, in unprecedented situations, the functionality of the MAPE-K loop often degrades, limiting its effectiveness. Moreover, In robotic applications, a distributed MAPE-K loop may be necessary for enabling adaptability across diverse deployment environments. To address this challenge, we propose a novel robotic software architecture designed to enhance trustworthiness, modularity and portability within the MAPE-K framework. Our approach introduces placeholders for trustworthiness checks to ensure robust operation in dynamic environments. Additionally, the architecture is developed in a distributed manner to enable scalability and portability across diverse robotic systems. The architecture is implemented using Python, with distributed backend for knowledge and communication handling to validate its performance, we conducted tests using a TurtleBot 4 use case, demonstrating the feasibility and benefits of our design.

It is often the case that a robot must adapt to unexpected changes in its environment. It is, however, important that these changes can be demonstrated to maintain the safe operation of the robot. The adaptive systems community has developed the MAPE-K pattern as a widely recognised conceptual architecture. We propose extending MAPE-K to incorporate runtime verification, resulting in an architecture we call MAPLE-K. In this paper, we capture and formalise both the MAPE-K and MAPLE-K architectures using a domain-specific language. Additionally, we provide support for translation from architectural models to software models and code to facilitate the deployment of verified applications. MAPE-K is rarely maintained at the implementation level, but our work ensures traceability between the code and its design, enabling the use of architectural information to verify the correctness of the software.

Ontological models for systems engineering, such as the Cross-Domain Knowledge Model (CDKM), now play an increasingly central role in engineering knowledge representation. However, as engineers from different domains contribute asynchronously to a single knowledge model, they often introduce inconsistencies that remain unnoticed. Version control systems, which are used to synchronize changes to such models, are however, content agnostic and, therefore, are not able to check semantic relations within a model. We introduce a framework designed to also maintain the semantic consistency of CDKM instances during concurrent, distributed editing. It operates in environments where engineers use version control systems to manage shared ontological models across interdisciplinary teams. This way, engineers can address problems faster and notice inconsistencies earlier by embedding this validation and correction process into their integration workflow.

The demand for ever more performant, intelligent, and safer cyber-physical systems (CPS) drives the development of increasingly complex control and monitoring algorithms. Embedded deployment of these complex algorithms is not straightforward, as the temporal behavior of the embedded platform can affect their functional behavior. It is desirable to evaluate this effect as early as possible in the development process to avoid costly redesigns. In this paper, we present a co-simulation approach to evaluate the expected performance of embedded applications after deployment. To achieve this, we first show how Discrete EVent System specification (DEVS) models can be included in Functional Mock-up Units (FMUs) to capture the temporal behavior of the embedded platform. For this, we leverage features introduced in version 3.0 of the Functional Mock-up Interface (FMI) standard. We validate our approach using two example cases, one where we compare to an existing state-of-the-art approach, and one using real-world performance measurements.

Model-based systems engineering (MBSE) focuses on using models to support the design, optimization, simulation, and ultimately deployment of complex cyber-physical systems (CPSs). These models enable reasoning about and predicting the behavior of the (realized) real-world system in silico. The value of using such (predictive) model depends on its validity against its real-world counterpart. As such, the validity context of a model is critical to ensure correct model use. Reasoning on validity is only possible if the validity of the model was captured explicitly at design time. In previous work, the validity frame (VF) was presented as a way to explicitly capture a model's validity; however, no guidance on the integration process within MBSE processes was given. Within this article, we present the creation and evolution of the model and its VFs to ensure model validity consistency and completeness. This evolution results in a set of interrelated models and VFs. By capturing these relations, we create a lightweight frame-enabled library of model variants. We show our contribution using an F1/10 vehicle simulation test bench.

The safety assessment of cyber-physical systems (CPSs) requires tremendous effort, as the complexity of cyber-physical systems is increasing. A well-known approach for the safety assessment of CPSs is fault injection (FI). The goal of fault injection is to find a catastrophic fault that can cause the system to fail by injecting faults into it. These catastrophic faults are less likely to occur, and finding them requires tremendous labor and cost. In this study, we propose a reinforcement learning (RL)-based method to automatically configure faults in the system under test and to find catastrophic faults in the early stage of system development at the model level. The proposed method provides a guideline to utilize high-level domain knowledge about a system model for constructing the reinforcement learning agent and fault injection setup. In this study, we used the system (safety) specification to shape the reward function in the reinforcement learning agent. The reinforcement learning agent dynamically interacted with the model under test to identify catastrophic faults. We compared the proposed method with random-based fault injection in two case studies using MATLAB/Simulink. Our proposed method outperformed random-based fault injection in terms of the severity and number of faults found.

As mechatronic systems become more complex, their design requires different engineering teams, each specialized in their own domain, to cooperate. This is often accomplished through a co-design process, which aims to parallelize the engineering work and therefore improve the time-efficiency and cost of system development. However, the integration step following the concurrent design often fails due to incorrect or incomplete assumptions made regarding other domains. In this paper, we propose to use a combination of two different views on the system. One view is the traditional system design methods that aim at system decomposition. The other view aims at defining the system-level properties and their interrelations. By means of a drone case study, we demonstrate how to decompose the system into manageable components, while still capturing relationships between these components and their related properties. For the drone modeling and decomposition, we use ARCADIA, whereas for the management of the cross-domain system relations, we use a knowledge model and tool that we presented in previous work.

The design and development of cyber-physical systems (CPS) inherently involves multiple engineering domains. As these systems become more complex, the different domains involved in their design become intertwined. In such situations, insufficient knowledge can lead to costly inconsistency and integration problems. In previous work, we proposed the use of a cross-domain knowledge model (CDKM) to capture these dependencies to support the architectural and detailed design stages of the development process. In this paper, we present early-stage research aiming to extend this approach to also support the verification and validation (V&V) stages, with the goal of enabling continuous V & V. To this end, we propose a megamodeling approach to provide traceability between different models, using the CDKM to provide a system-level overview of the CPS under development.

Model-based systems engineering (MBSE) techniques can help manage the growing complexity in the design and development of cyber-physical systems, and can even allow for the optimization of a system under design in simulation. However, models are always an abstraction of the real-world systems they represent. This introduces uncertainty at the model level, which affects the validity of simulation results, and thus also the results of the optimization. This, together with variations in real-world system parameters, significantly complicates the validation of simulation and optimization results. In this experience report, we first use a descriptive process model to describe our efforts to validate the results of a model-based design space exploration (DSE) process given this uncertainty. After this, we discuss lessons learned and insights gained, and identify future challenges. We present a possible prescriptive process model for future validation efforts, which specifically takes into account uncertainty.

The complexity of mechatronic systems is vastly increasing. Therefore, the design of these systems requires different engineering domains, e.g., the mechanical, electrical, and control domains, to work together. The different domains often work in parallel to gain efficiency in this so-called co-design process. However, the design choices made by engineers in one domain can influence parameters in another domain. Too little or even no knowledge about these cross-domain influences may later lead to system integration problems or to degraded system performance. Solving these problems requires taking steps back in the development process, causing a higher design cost. In order to improve this cross-domain collaboration, we propose using ontologies to assist the co-design process by explicitly capturing the design dependencies, both within and across the engineering domains. However, designing ontologies can be complex and is labor-intensive, especially if one relies on generic ontology languages like the Web Ontology Language 2 (OWL 2). Therefore, we created a Domain Specific Language (DSL) focusing on the essential complexity, which enables engineers to design a cross-domain system ontology in a consistent and straightforward way. We elaborate on the metamodel for this DSL, discuss the realization of a prototype tool, and demonstrate how one can then reason on this ontology to derive new information about the various cross-domain design relationships.

During the product design, special attention is required to ensure that the product can be assembled later on at the manufacturing floor. Front-loading the assembly or production knowledge is advantageous for the efficiency of the product design process as it limits the costly design iterations. However, this front-loading results in a big design-space , requiring computational-intensive exploration mechanisms to find an optimal design. We propose a two-stage exploration and optimization method. Within first stage, both product and assembly knowledge, captured in an ontology and their trade-offs, captured in design contracts, are used to preliminary prune the design-space. Within second stage, we explore the reduced design-space to find optimal design.

Cyber-Physical Systems (CPSs) are increasingly used in various safety-critical domains; assuring the safety of these systems is of paramount importance. Fault Injection is known as an effective testing method for analyzing the safety of CPSs. However, the total number of faults to be injected in a CPS to explore the entire fault space is normally large and the limited budget for testing forces testers to limit the number of faults injected by e.g., random sampling of the space. In this paper, we propose DELFASE as an automated solution for fault space exploration that relies on Generative Adversarial Networks (GANs) for optimizing the identification of critical faults, and can run in two modes: active and passive. In the active mode, an active learning technique called ranked batch-mode sampling is used to select faults for training the GAN model with, while in the passive mode those faults are selected randomly. The results of our experiments on an adaptive cruise control system show that compared to random sampling, DELFASE is significantly more effective in revealing system weaknesses. In fact, we observed that compared to random sampling that resulted in a fault coverage of around 10%, when using the active and passive modes, the fault coverage of DELFASE could be as high as 89% and 81%, respectively.

As cyber-physical systems become more complex, the engineering domains involved in their design become more and more intertwined. In these situations, a traditional (sequential) design process becomes inefficient in finding good design options, likely requiring multiple (costly) iterations to arrive at a good overall design. Instead, an integrated approach is desired where design variables in multiple different engineering domains can be chosen, evaluated, and optimized to achieve a good overall solution. However, in such an integrated approach, the combined design space becomes vast. As such, an efficient design space exploration (DSE) workflow is needed to minimize the computation time required to find good solutions. In the current paper, we present an approach to automatically determine efficient design space exploration workflows for engineering problems involving multiple engineering domains, such as mechatronics. We do this by explicitly capturing and modeling the relationships between system properties across different engineering domains. We then use this information to generate a set of possible DSE workflows. We also present a method for evaluating these generated workflows based on the expected computation time required to execute them. We demonstrate this approach using a simple example case study and compare the automatically determined DSE workflow to a previously manually determined workflow.

During the product design, special attention is required to ensure that the product can be assembled later on at the manufacturing floor. Therefore, front-loading the assembly or production knowledge is advantageous for the efficiency of the product design process as it limits the costly design iterations when product assembly turns out challenging or even impossible. However, front-loading this assembly knowledge does push the complexity of the product design as it shifts to a clear co-design process in which multiple domain experts work together using their specialized domain tools. Within this paper, we propose the use of a Knowledge Base to ease the knowledge exchange between both different stakeholders and tool environment. Such a Knowledge Base does ease a co-design by providing proper handles for (I)Data integration, (II)Data exchange between tools, (III)Data exchange between stakeholders. We present both the development and application process to standardize the build and usage activity of such project-specific Knowledge Base. The benefits are demonstrated on a Small Validation Case of a gearbox.

Model-Based Systems Engineering (MBSE) provides workflows, methods, techniques and tools for optimal simulation-based design and realization of complex Software-Intensive, Cyber-Physical Systems. One of the key benefits of this approach is that the behavior of the realized system can be reasoned about and predicted in-silico, before any prototype has been developed. Design models are increasingly used after the system has been realized as well. For example, a (design) digital twin can be used for runtime monitoring to detect and diagnose discrepancies between the simulated and realized system. Inconsistencies may arise, however, because models were used at design time that are not valid within the operating context of the realized system. It is often left to the domain expert to ensure that the models used are valid with respect to their realized counterpart. Due to system complexity and automated Design-Space Exploration (DSE), it is increasingly difficult for a human to reason about model validity. We propose validity frames as an explicit model of the contexts in which a model is a valid representation of a system to rule out invalid designs at design time. We explain the essential and conceptual, yet practical, structure of validity frames and a process for building them using an electrical resistor in the optimal design of a high-pass filter as a running example. We indicate how validity frames can be used in a DSE process, as well as for runtime monitoring.

The increasing complexity of Cyber-Physical Systems (CPS) causes a shift from traditional single-core embedded platforms to complex multi-core or even heterogeneous platforms to meet the performance requirements. However, the deployment of control or monitoring algorithms on such platforms is not straight-forward as the temporal behaviour of the embedded platform can affect the functional behaviour of these algorithms. In this paper we propose a co-simulation strategy for multi-core embedded platforms. This allows to evaluate the impact of the deployment on the behaviour of the algorithm early on in the design process, this way reducing the risk of costly re-engineering and allowing for a more agile design process. Our approach is validated using an example case in different deployment scenarios, after which its applicability is demonstrated using a real-world use case.