This paper introduces and makes available the first structured dataset for data-driven risk assessment in industrial machinery functional safety. The dataset comprises 7800 hazard scenarios generated using a rigorous, ISO 12100 and ISO 138491 grounded methodology, including plausibility assessment. The dataset spans ten hazard types, incorporating contextual parameters and corresponding required performance level (PLr) for each hazard scenario. The utility of the dataset and its application as a benchmark is demonstrated by comparing LLM-only and RAG-enhanced hazard classification as one example application. Experiments show that that RAG significantly improves LLM accuracy in classifying hazard scenarios and predicting PLr by providing access to critical contextual information (e.g. guidance from ISO 13849-1 for determination of PLr), resulting in a 36.4% average accuracy increase (72.8% accuracy) compared to the LLM-only baseline (36.4% accuracy). Furthermore, RAG reduced misclassification rates across all hazard types, with the highest misclassification dropping from over 70% in the LLM-only case to a maximum of 29% with RAG indicating significantly enhanced classification confidence confirmed by statistical tests. These findings demonstrate the dataset’s ability to address the gap in structured data for evaluating LLMs in functional safety tasks, potentially leading to more reliable and efficient automated risk assessments. This work provides a valuable, open-source resource (GitHub repositry) to facilitate collaborative research and adoption of AI in routine functional safety workflows.

Industrial Automation and Control Systems (IACS) increasingly face security challenges. While refactoring enhances code maintainability, improper restructuring in custom IACS software can introduce new vulnerabilities. Applied without security awareness, refactoring may weaken access controls, aggregate sensitive data, or disrupt validation mechanisms, expanding the attack surface. This work presents a risk-based prioritization methodology for refactoring data clumps, integrating security factors such as Data Sensitivity (DS), Input Validation Inconsistency (IVI), and Access Control Inconsistency (ACI) alongside traditional maintainability metrics in a structured, quantifiable approach to security-aware refactoring. Empirical validation on five open-source projects reveals that security-sensitive functions are 63% more likely to exhibit long parameter names (LN) and high numbers of parameters (NP), highlighting a strong correlation between code complexity and security risk. This study provides actionable insights for identifying high-risk code structures and mitigating vulnerabilities through security-focused refactoring, forming the foundation for risk-informed strategies in large-scale IACS software.

In this paper, a novel chatbot for risk reduction as an aid during machinery design is presented. The general workflow of the chatbot involves the identification of the hazard described by the user using a neural network model followed by an interactive dialog based conversation, in which the risk reduction measures are outlined. A prototype implementation of the chatbot presents the steps to generate and pre-process the training data for Artificial Intelligence (AI) based models. Different neural network models are trained and evaluated for the proposed risk reduction chatbot. A comparative study is presented by employing an in-depth qualitative and quantitative evaluation. The work presented in this paper shows significant promise in ensuring safety awareness, thereby aiding in implementing functional safety in the early stages of machinery design and development.

The use of Artificial Intelligence (AI) in machinery functional safety can enhance efficiency and accuracy by automating tasks previously carried out by humans. This paper presents an experimental evaluation of Neural Network (NN) models for hazard identification in machinery functional safety. The systematic study includes own implementations of NN models using open source building blocks and the use of an open source conversational AI framework with various pipeline configurations. The paper provides a comparative analysis of the qualitative and quantitative parameters for the models and configurations.

Safety awareness is extremely important when Artificial Intelligence (AI)/Machine Learning (ML) is introduced in the functional safety domain. This paper shows a way to bring the characteristics of the ML development process as well as their particular characteristics into a consensus of the engineering process of functional safety and its reliability requirements.

Standards such as ISO 13849 and ISO 12100 enable users to model safety related control elements with safety functions, according to a specified architecture and required performance level. In this direction, a novel Artificial Intelligence (AI)-based assistant is introduced in this paper to aid in determining the required performance level parameter by indulging the user in a dialog-based conversation regarding hazard scenarios. This will help inexperienced machinery safety personnel (e.g. mechanical engineer) to get an overview of the safety engineering aspects, before consulting with safety experts for risk assessment.

In this paper we propose an approach for an integrated and iterative performance tuning of an Industrial Internet of Things (IIoT) digital twin. Using the systematic series of steps in the proposed approach, the digital twin- linked to its real-world counterpart, can now be used in different ways to predict, refine, fine tune and optimize the operation of the asset (e.g. Cyber Physical System (CPS) in the IIoT plant) during various stages of its software development life cycle.

Standards such as IEC 61508 or ISO 26262 provide a general guideline on how to develop embedded systems in a safety-critical context. However, they offer no actual support for the implementation of safety mechanisms. This paper proposes such development support by employing Model Driven Development (MDD). For this, we target the issue of soft errors, which may lead to silent data corruption due to radiation effects. We propose an MDD workflow including a model representation and model transformations, which are able to automatically generate memory protection for variables inside a program based on a model specification via UML stereotypes.

Internet of Things (IoT)-enabled applications are gaining inroads in various domains. Several IoT platforms, with support for rich set of device libraries, facilitate rapid development of embedded IoT applications. But, none of the approaches deal with an early analysis of performance characteristics such as energy and timing properties. Such analysis (and feedback) during early design stages would help in identifying problems in meeting the performance attributes, reduce development time/effort, and deliver better quality without budget overshoot. Addressing this gap, a novel, generic workflow to carry out a quick, early, model-driven, system-level energy-aware timing validation of IoT-enabled hand-written code in specialized timing analysis tools, such as SymTA/S, is proposed in this paper. A prototype of the workflow is realized using a light-weight interfacing tool framework (with plug-ins) employing the Eclipse environment. A discussion on the various implementation aspects of the workflow and its qualitative and quantitative analysis based on experiments on real-world, model-based, IoT-enabled use cases of varying complexities is presented. The IoT-enabled emission monitoring system described in this paper is a full-fledged use case (in its completeness) and tested including live data captured from emission monitoring with the IBM Watson IoT platform. A tradeoff analysis among the energy and timing characteristics of an IoT-enabled automotive real-time emission monitoring use case, with the aid of the workflow/prototype implementation is presented in a timing-energy analysis tool. The main benefit of the proposed workflow is the feedback regarding energy and timing characteristics of the IoT-enabled application, early during development stages. Such analysis results providing early feed back regarding performance characteristics (load and schedulability) of the IoT application software system can be termed as a breakthrough for software architects and design engineers toward realizing reliable and cutting edge IoT-enabled systems.

Several IoT platforms, with support for a rich set of device libraries, facilitate rapid development of embedded IoT applications. But, none of the approaches deal with the analysis of performance characteristics. An example is the early timing validation of IoT use cases in specialized timing analysis tools. Addressing this gap, a generic workflow for a quick, early model-driven, system-level timing validation of IoT compliant hand-written code in specialized timing analysis tools, such as SymTA/S, is proposed in this paper. A prototype implementation of the workflow and its experimental evaluation in a novel, IoT-compliant real-time emission monitoring use case is presented. The main benefit of the proposed workflow is the early feedback regarding performance characteristics of the embedded IoT application, under varying timing constraints.

In model-based Embedded Software Engineering (ESE), individual systems are modeled with chains of components that are translated to chains of tasks/runnables for a scheduling analysis. Early analysis of response time of such systems (e.g. end-to-end path delay) provides important feedback to understand how the function blocks/components in the system may actually behave. In this paper we report on work in progress pertaining to an overall workflow for model-driven specification, translation and validation of such timing constraints in ESE projects developed using Matlab/Simulink. The challenges addressed in this workflow and future directions are outlined.

In the recent decade, many formalisms and tools have emerged for model-driven Non-Functional Property (NFP) specification and assessment. In this direction, model-driven reliability and safety assessment of engineering systems developed using Matlab/Simulink is an emerging research challenge. However, a generic mechanism for NFP specification in the Simulink design model is not yet supported. Further, a completely automated model-based workflow for synthesis of a NFP analysis model and its subsequent analysis in a NFP analysis tool is missing. In this context, this paper proposes a novel approach and a fully automated workflow towards model-driven reliability analysis of Simulink models. An approach to annotate the Simulink design models with reliability attributes and subsequent synthesis of fault trees from the annotated design model is described. A prototype and initial experimental results are discussed.

The increasing complexity of realtime embedded software systems necessitates them to support a variety of functions. Therefore, a practice is to split the overall system into different sub-systems and use various (modeling) tools for describing different parts of the system. On the other hand, though guaranteeing realtime properties forms an integral part of realtime embedded software development, it is often overlooked during system specification. Thereby, much effort is needed to solve timing problems, when they occur after implementing a system. Therefore, it is desirable to specify and validate timing properties during early development stages. As different parts of an overall system can be developed using various tools, elements which influence the timing behavior can be located in different sources. In order to analyze the overall timing behavior with a timing validation tool, all timing properties of the overall system are needed. Therefore, this paper presents an approach to couple timing properties from different sources. The approach allows to create links between elements across different sources and to synchronize timing properties. Thereby, timing properties can be followed, kept consistent and combined to be validated.

In Embedded Software Engineering (ESE) scenarios involving heterogeneous modeling domains, the sub-systems may be developed using more than one modeling domain. In such scenarios, the need arises for co-engineering and model-based synchronization of Non-Functional Properties (NFPs) which are spread/linked across various modeling domains, before performing an NFP analysis. This paper proposes an integrated, generic workflow for model-based co-engineering and NFP analysis of embedded software systems developed by interdisciplinary teams, using heterogeneous modeling domains. Based on this workflow, a mechanism for model-based co-engineering and reliability analysis of an embedded software system, developed using Unified Modeling Language (UML) and Matlab/Simulink is discussed. An experimental evaluation of the proposed mechanism is presented.

In the domain of embedded systems, the complexities involved in embedded software development are being successfully addressed by the emerging field of model-based software development and testing. However, in embedded systems, the underlying embedded software is often expected to collaborate with various hardware, mechanical, electrical modules/technologies. To address this aspect of heterogeneity in embedded systems, practitioners of model-based embedded software engineering are required to use more than one modeling language. This is essential to address the multi-faceted design aspects/requirements of an embedded system. This paper elaborates on the existing data interchange and coupling mechanisms between embedded software sub-systems modeled using UML and Matlab/Simulink. While there are some existing coupling mechanisms for data exchange among heterogenous modeling domains, they are all not applicable to all real-time operating systems and/or limited to a few simulation studies. This paper addresses the aforementioned gaps and proposes a simple, generic methodology for data exchange between events (in UML domain) and signals (in Matlab/Simulink domain). The proposed approach is elaborated using a seesaw (real-word) embedded software system application scenario example. Initial prototype implementation of the proposed approach, experimental results and some future directions are outlined.

Model Driven Development (MDD) is deemed as a key to address the increasing complexity of software systems. It is imperative that the developed software fulfills the end-user's requirements. This implies that a collaboration between the Requirements Management (RM) tools and the modeling tools, enabling complete traceability and interfacing among these tools, is essential. On the other hand, existing tools collaborating between RM and modeling tools support a very limited sub-set of new features (e.g. traceability analysis) and are compatible with only a few tools. As a result, software engineers are often required to educate themselves on another (often complex), intermediate (collaborating) tool, merely to realize a very limited sub-set of supported features. This paper addresses these gaps and introduces an approach for exchanging information between RM tools and Unified Modeling Language (UML) tools by using the standardized Requirements Interchange Format (ReqIF). The proposed approach (a) enables software developers to create links between requirements and UML elements in their modeling tool and (b) facilitates requirements engineers to make traceability/other analyses down to linked model elements inside their RM tool. In contrast to many other approaches, no additional user interface is needed for traceability.

Embedded software development is moving towards the model-based paradigm to support the complexity of today's embedded systems, as they become more and more important and omnipresent in our daily lives. In this context, the Unified Modeling Language (UML) is a widely used standard. Code generators can be executed to generate source code from UML models. Usually the code generators are proprietary for one UML tool. If code generators for different targets or programming languages have to be supported by various modeling tools, the wheel must be reinvented. Code generators could use the standardized Extensible Markup Language Metadata Interchange (XMI) format of the UML as a basis. However, tools export their data to XMI differently. Therefore, the paper shows how the proprietary models of UML tools can be mapped to a standardized UML model. This is realized by using techniques for model to model transformations. These techniques need a meta-model for the source and the target model. Hence, an approach is introduced for creating meta-models for Application Programming Interfaces (APIs) of UML-tools, which act as a facade. Then the code generators can work with the standardized UML model to generate the source code. This results in an improved scalability of the code generators.

The existing model-based tools employ runtime monitoring methodologies for debugging and testing of embedded systems. In these tools, the additional instrumentation for incorporating and executing the test code varies based on the application. Such techniques could also introduce significant, non-deterministic overhead in the embedded system. This is a hurdle in applying Model-Based Testing (MBT) for resource constrained embedded systems and industrially relevant examples. To address this gap, this paper elaborates on the monitoring methodology used in a test framework for executing the model-based test cases in the embedded system. Two variants of the proposed monitoring methodology, (a) software and (b) on-chip monitoring are discussed. An empirical evaluation based on a prototype implementation of the proposed runtime monitoring mechanisms is discussed.

The growing variety and complexity of embedded software development necessitates the usage of structured embedded software engineering and automation approaches such as the model-driven methodology. Whereas there are several modeling domains and tools to support embedded software development, coupling of embedded software subsystems developed using heterogeneous modeling domains is still an emerging field. This paper outlines a novel approach towards the development of a generic middleware aimed at automated source codelevel coupling of embedded software-subsystems developed using heterogeneous modeling domains (e.g. UML, Matlab/Simulink). The proposed approach, initial results and future directions are outlined.

Model-based approaches to develop software for embedded systems are becoming increasingly important in the last ten years. In this context, it is desirable to carry out debugging at the model level in conjunction with the model-based development of embedded software. This paper presents such a model-based debugging approach which can be used to visualize the behaviour of embedded software on a host PC. The various constraints in embedded software development and execution pose a big challenge to monitor the embedded system without affecting its runtime behaviour. The focus of this work is to describe the underlying monitoring mechanism and the methodology to visualize the embedded system behaviour in real time. This includes different approaches to get the trace data from the target without or with minimal influence on the runtime behaviour of the monitored embedded system.

Model-based methodologies such as the Model-Driven Development (MDD) and Model-Based Testing (MBT) are being explored, in the recent decade, for automation in embedded software engineering projects. In this context, the target of this paper is to demonstrate the adoption and applicability of the Unified Modeling Language (UML) and the UML Testing Profile (UTP) for deploying MBT in Resource-Constrained (RC)-Real-Time Embedded Systems (RTES). Though the UTP standard has been introduced several years ago, concrete approaches or tool support for generating the test artifacts based on the UTP is currently unavailable. This paper aims to close this gap and discusses a concise set of UTP artifacts in the context of MBT for RC-RTES. A detailed discussion on the test artifacts generation algorithm demonstrating the applicability of our approach in a real-life RC-RTES example is presented.

Model driven design and development of real-time embedded systems has been gaining a lot of attention in the recent past. It is imperative for a hard real-time embedded system to execute and respond to sequenced exchanges of messages under critical temporal constraints. The UML provides artifacts such as communication diagrams, sequence diagrams and timing diagrams to aid software engineers to model and precisely document such a schedule of interactions or state changes at the design level. While modeling at the design level is interesting on one hand, it is also significant to understand the run time behavior of the embedded software. A step forward in this direction is to provide a real-time representation of the target system behavior on the host side. We propose an approach to realize a target debugger on the host side with a monitor solution in the target side. With the back annotated information from the target, a visual representation of the system behavior in real-time is now available at the design level. This way, a debugging solution in real-time is provided, thus taking a step forward towards understanding the behavior of the embedded software at hand. We illustrate our proposed approach with a prototype and examples.