Simulation Based Design of Control Systems Using DEVS and Petri Nets

System models are constructed to design, study, and understand complex systems. According to the systems modeling language (SysML) that is a standard for model-based system engineering, all engineering activities should be performed using a common model. To validate complex system models defined in SysML, simulation is usually employed. There are numerous efforts to simulate SysML models using different simulation methods and tools. However, the efficient support of automated generation of executable simulation code is still an issue tangled by the research community. This paper introduces DEVSys, an integrated framework for utilizing existing SysML models and automatically producing executable discrete event simulation code, according to model driven architecture (MDA) concepts. Although this approach is not simulation-specific, discrete event system specification (DEVS) was employed, due to the similarities between SysML and DEVS, mainly in system structure description, and the mature, yet ongoing research on expressing executable DEVS models in a simulator-neutral manner. DEVSys framework elements include (a) a SysML profile for DEVS, enabling integration of simulation capabilities into SysML models, (b) a meta-model for DEVS, allowing the utilization of MDA concepts and tools, (c) a transformation of SysML models to DEVS models, using a standard model transformation language as query/view/transform (QVT), and (d) the generation of DEVS executable code for a DEVS simulation environment with an extensible markup language (XML) interface. The definition and implementation of DEVSys elements, as well as the process for its application are demonstrated and discussed, with the aid of a simple working example.

Real-time systems modeling and verification is a complex task. In many cases, formal methods have been employed to deal with the complexity of these systems, but checking those models is usually unfeasible. Modeling and simulation methods introduce a means of validating these model’s specifications. In particular, Discrete Event System Specification (DEVS) models can be used for this purpose. Here, we introduce a new extension to the DEVS formalism, called the Rational Time-Advance DEVS (RTA-DEVS), which permits modeling the behavior of real-time systems that can be modeled by the classical DEVS; however, RTA-DEVS models can be formally checked with standard model-checking algorithms and tools. In order to do so, we introduce a procedure to create timed automata (TA) models that are behaviorally equivalent to the original RTA-DEVS models. This enables the use of the available TA tools and theories for formal model checking. Further, we introduce a methodology to transform classic DEVS models to RTA-DEVS models, thus enabling formal verification of classic DEVS with an acceptable accuracy.

Two methodologies and technologies are integrated in this paper: distributed object-oriented programming and visual programming with object-oriented Petri nets (OOPNs). Distributed object-oriented systems are represented by means of active objects, called actors. A formal specification of actors is achieved by means of OOPNs, which are based on colored Petri nets enriched by the object-oriented paradigm. We combine these methods into a single methodology for the formal specification of distributed systems with actors by means of OOPNs. OOPNs are based on viewing objects as active servers that offer re-entrant services to other objects. A class consists of an object net, describing the internal activity, and several method nets, describing the services the class provides to other classes.

Petri nets have been extensively applied for specification, design, verification, performance evaluation, and simulation of discrete-event control systems. A real-time Petri net is a further improvement over the timed Petri net. The paper proposes to use a real-time Petri net to represent the stage programming of a programmable logic controller for a discrete-event control system. An illustrated example is used to explore the Petri net-based PLC stage programming methodology.

Petri nets have proven to be a valuable tool for modelling concurrent systems. As such, they should be suitable for modelling agent and multi-agent systems, as these are inherently concurrent. Nevertheless, there are not many systems that allow modelling of the whole multi-agent system in Petri nets. The use of Petri nets is usually limited to sub-problems, such as verification of interaction protocols. This paper describes the main concepts of PNagent - a tool for modelling BDI agents using the formalism of object oriented Petri nets (OOPN). PNagent allows development, testing and running software agents in a consistent graphical environment. The framework is suitable for prototyping and experiments with both multi-agent applications and the particular agent architecture itself. At the same time, thanks to the formal nature of its underlying paradigm, it provides means for verification of agentpsilas properties.

Airborne systems are considered to compose a highly complex network of interconnected Cyber-Physical Systems (CPS). Following the ARP-4754A development guidelines, a series of multidisciplinary engineers have to decompose system, hardware and software requirements in order to validate their correctness. System intrinsic complexity though, imposed by CPS(s), constitutes the certification of airborne systems a difficult, time-consuming and often expensive task. In the same line, requirements traceability, validation and verification is considered to be a crucial part of certification processes for both hardware (DO-254) and software (DO-178C) components. In this paper we review challenges and solutions for software certification under the DO-178C standard using formal verification in line with new CPS analysis evolution. We describe current model-based design methodologies followed today in the aerospace domain and comment on new approaches and techniques that could accelerate the software certification processes with respect to CPS(s) requirements.

Dynamic reconfigurable simulation based on Discrete Event System Specification (DEVS) requires efficient verification of simulation models. Traditional verification method of DEVS model is based on I/O test in which a DEVS model is regarded as a black box or a grey box. This method is low efficient and insufficient because input samples are often limited. This paper proposes a formal method which can translate Parallel DEVS model into a restrict kind of Timed Automata (TA) with equivalent behaviors. By this translation, a formal verification problem of Parallel DEVS model can be changed into the formal verification of according timed automata.

In order to support the conceptualization and specification of simulation models of complex systems, several formalisms or world views exist. Petri nets, differential equations, discrete event system specification and process interaction are typical examples. Throughout the last decade many have attempted to implement the process interaction formalism in Java. These initiatives mostly resulted in multi-threaded simulation languages in which a process extends a thread. These threads are then sequentially suspended and resumed. The article "Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?" (Sun Microsystems 1999) implicitly ended most of these deadlock prone initiatives. This paper introduces a unique single-threaded implementation of this world view by introducing a Java-based Java interpreter, which is used only to interpret pausable processes. This interpreter supports all Java programming constructs and hopefully serves as a cornerstone for renewed development of process oriented Java based simulation languages.

This paper is a logical pursuit of our investigations in modelling and control research of flexible assembly systems with object oriented Petri nets. In our previous work (1993), we presented a methodology of operating process control which concerns subassemblies. The subassembly management included input generic planning of product families and output product families. We also developed a method of how to manage generic planning with process sequencing. Indeed, this step is the static study of flexible assembly systems. The aim of the present paper is to show how to structure the dynamic part of the system, from the input parts and resources of manufacturing up to the assembled product output to the customers.

PSEE (Process-centered Software Engineering Environment) can manage and monitor software process. Software process modeling language is a core element in PSEE system. Due to the particularity and the complexity, software process model includes multi-views: activity view, product view and role view, which should be considered in modeling software process. Based on the similarity between multi-view software process modeling and object Petri nets, this paper proposes the MOPN-SP-net model which is a multi-view software process model based on multi-object Petri nets. The model includes twolevel models: system net and object net. A multi-view paradigm including activity views and product views is provided. Activity views are described by system nets and product views are described by object nets. MOPN-SP-net includes multi-views of software process model, which is characterized with clearer hierarchy, simpler structure, and more extendibility.

In this paper we propose a multi-agent intelligent tutoring system building tool that integrates different formalisms in order to facilitate the teacher task of developing the contents of a tutorial system and at the same time to provide adaptiveness and flexibility in the presentation. The adopted formalisms are ground logic terms for the student model, data-bases for the domain model and object Petri nets for the pedagogical model. The interaction between the student and each agent of the system is controlled by an object Petri net, automatically translated into a rule-based expert system. The object Petri net tokens are composed by data objects that contain pointers to the student model and to the domain knowledge, stored into a data-base of texts, examples and exercises. The object Petri net transitions are controlled by logical conditions that refer to the student model and the firing of these transitions produce actions that update this student model.

Large and complex systems, such as the Smart Grid, are often best understood through the use of modeling and simulation. In particular, the task of assessing a complex system's risks and testing its tolerance and recovery under various attacks has received considerable attention. However, such tedious tasks still demand a systematic approach to model and evaluate each component in complex systems. In other words, supporting a formal validation and verification without needing to implement the entire system or accessing the existing physical infrastructure is critical since many elements of the Smart Grid are still in the process of becoming standardized for widespread use. In this paper, we describe our simulation-based approach to understanding and examining the behavior of various components of the Smart Grid in the context of verification and validation. To achieve this goal, we adopt the discrete event system specification (DEVS) modeling methodology, which allows generalization and specialization of the entities in the model for a customized simulation with specific scenarios. In addition, we articulate metrics for supporting our simulation-based verification and validation and demonstrate the feasibility and effectiveness of our approach with a real-world use case.

We describe here a systematic method for the design and modeling of flexible manufacturing systems, using object-oriented concepts and Petri nets. We first define the system components in terms of an object model consisting of hierarchical sets of classes and associations. Then, we model the dynamic aspects of the system using statecharts, including exceptions and abnormal behavior. As a third step, we derive Petri nets from those statecharts to realize the concurrency present in the system. Finally we develop a hierarchy of controllers, corresponding to the layers of the object model, for the independent components of the system based on the Petri nets obtained in the previous step. The approach is systematic and relatively easy to apply. It is illustrated through a realistic example. >

An approach is presented for generating a performance prediction model so that both qualitative (logical correctness) and quantitative (timeliness) properties of a real‐time system can be evaluated. The architecture of a system is layered into a functional layer and a physical one. Both architectural layers are developed as executable models: the executable functional model is a Petri net and the executable physical model is a queuing net. The two‐layered executable models are then connected to develop a performance prediction model. A message‐passing pattern is generated from the Petri net using a state space analysis technique. Then, the queuing net model processes these messages preserving the pattern. Once the network delays are obtained from the queuing model, their values are inserted back into the Petri net model. Since the communication service demands are isolated from the executable functional model, the communications network can be specified independently at any preferred level of detail. This enables the executable functional model to be invariant with respect to the executable physical model resulting in additional flexibility in designing a large‐scale information system. This property, together with the synthesis technique, enables both formal and simulation methods to be used together, when each one utilizes a different self‐contained commercial‐off‐the‐shelf software application. © 2002 Wiley Periodicals, Inc. Syst Eng 6: 1–18, 2003

The verification formalism / modeling and simulation language hybrid Chi is defined. The semantics of hybrid Chi is formally specified using Structured Operational Semantics (SOS) and a number of associated functions. The χ syntax and semantics can also deal with local scoping of variables and/or channels, implicit differential algebraic equations, such as higher index systems, and they are very well suited for specification of pure discrete event systems.