Selected Publications

This paper deals with the embedded systems construction process based on the system specification modeled as a set of Petri nets. Modeling of the system starts with Workflow Petri Nets specification describing the main modules and processes within the system. Workflow model is then transformed to the multilayered Reference Nets structure, that is finally used for the code generation of the target system. The main goal of our approach is to provide for dynamic reconfigurability of the system deployment according to the changes within its specification. The heart of the system lies within the reference nets hosting platform called Petri Nets Operating System (PNOS) that includes the Petri Nets Virtual Machine (PNVM) that performs the very Reference Nets interpretation.

The aim of the paper is to show basic elements of a system design methodology which uses Object oriented Petri nets. The methodology features conformity with UML and uses simulation as a means to verify the models in all system development phases. Simulation also helps in making decisions about structural and behavioral specification of the system. The paper will demonstrate layered modeling technique based on Object oriented Petri nets.

The UML class diagram defines a basic architectonic model of the system. Its behavior is then usually described by other UML diagrams, such as activity diagrams, sequence diagrams, etc. These models serve for the design purposes and are automatically or manually transformed in the next development stages, typically to the models with formal basis or to implementation (production) environment. There is no backward step allowing to investigate the system structure and its behavior with the designed models. On the other hand, there are approaches to system design combining design, testing, and implementing stages into one development technique. One of them uses Object Oriented Petri Nets (OOPN) as basic modeling formalism. Nevertheless, OOPN lacks for advisable architectonic view of modeled systems as it is offered by UML class diagram. The paper is aimed at using UML class diagrams for system architecture description and the OOPN formalism for description of classes behavior. Since UML classes and OOPN classes partially differs, we define formal transformation between UML classes and OOPN classes.

This particular paper describes our most recent work on our system called JAWS. This system is intended to control and monitor Wireless Sensor Network. In principle, JAWS is agent system built on JADE platform. It consists of several agents that are able to communicate with Wireless Sensor Nodes. Via communication, we are able to obtain values from particular sensor nodes called motes. We are also able to inject mobile code to each mote so we can basically change behaviour of that mote and in extension of whole network. In this paper we explain our use of concept of services in our system. As will be shown, services are natural and most viable concept in our approach to control and monitor Wireless Sensor Network. We will briefly describe basic concepts of our system and explain all kinds of services that can be used within our system, which is the most narrow scope of this paper. We also describe few protocols that we use and that are bound to services.

The paper is aimed at such development processes, which work with formalisms allowing to design architecture and functionality, analysis of design, testing and system run with no need to change this formalism. It deals with UML, Petri Nets, and DEVS application in the systems design and sketches a method how to use the formalisms for modeling a system architecture and its behavior. Its combination decreases a number of transformations of models and makes the architectural description well-arranged.

This paper describes a tool for monitoring and controlling wireless sensor network. On nodes of wireless sensor network there runs WSageNt system that enables us to run BDI style agents on individual nodes of network. The tool allows to store and present data obtained from agents and to control behavior of the network.

The paper deals with application of OOPN formalism in the area of system design and demonstrates modelling techniques of OOPN on the case study of conference system design.

The paper describes an approach to Simulation Based Design (SBD) of systems, which combines design models with simulation models. The presented approach uses formalisms which can be used for system design as well as system analysis-High-level Petri nets, objects and systems-theoretic approach represented by DEVS formalism. The paper outlines the design methodology of SBD based on the formalism and demonstrates a technique of simulation analysis on the simplified example.

Modeling distributed system and modeling intelligent system means that we create a model of a system with corresponding behavior. Multiagent systems are complex systems implementing a platform which is responsible for agent management including inter-agent communication, an agent specification, its behavior, etc. There are many agent platforms that are primarily intended for different applications. The paper deals with an integration of T-Mass and PNagent agent platforms. PNagent implements agents using Object Oriented Petri Nets allowing high-level view to the designed system while T-Mass was developed for usage in systems with limited resources, e.g., Wireless Sensor Networks. The integration is made using the JADE platform as a common base.

Main purpose of this paper is to show how to interconnect two different platforms whereas the one is FIPA (Foundation of Intelligent Physical Agent) compliant. We interconnected the FIPA reference implementation JADE with the PN agent platform, which is a BDI agent implementation based on the formalism of Object Oriented Petri Nets. When we make PN agent FIPA compliant we open new world of possibilities how to use Petri nets in cooperation with other agent platforms.

PNtalk is a tool based on Object Oriented Petri nets. It is intended for systems modeling, simulation and prototyping. In some situations, it is also possible to use it as a programming language and a framework for final implementation of the systems. The paper presents a meta-level architecture of the PNtalk kernel and and demonstrates its reflective features. These features are crucial for the systems development process as well as for the systems maintenance. The usage of the PNtalk metaobjects are demonstrated by examples.

Current model-based design methodologies use executable semi-formal models allowing for transformations including code generation. Nevertheless, the code should be finalized manually and further development or debugging by means of prime models is impossible. The paper introduces an approach to the system design called Simulation Based Design which uses formalisms of DEVS (Discrete-Event Systems Specification) and Object Oriented Petri Nets (OOPN) allowing for clear modeling, a possibility to check correctness by means of simulation. The approach is based on techniques such as incremental development in the simulation, reality-in-the-loop simulation, and model-continuity.

The paper presents an approach to the system development, which is based on the concept of simulation based design allowing to see the system as a set of models in every development stage including its deployment. It presents special modelling techniques allowing to access models from other programming environment and to generate model templates.

This paper describes the main concepts of PNagent-a tool for modelling Believe-Desire-Intention (BDI) agents using the formalism of Object Oriented Petri Nets (OOPN). PNagent allows for developing, 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. Thanks to its consistent environment and the high-level nature of the used formalism, the framework is also suitable for incorporating the ideas of autonomic computing.

The presented text describes a new approach to building artificial agents and Multi-Agent Systems using the methodology of model-based design. In this methodology some models are used for testing the behaviour of particular elements as well as for testing the behaviour of the system as a whole-in both cases by simulation. Our aim is to develop a tool that would allow model-based design of systems with artificial agents. For this reason we have been building an application called Tool for Multi-Agent System Simulation (T-Mass) which is aimed at model-based development. As a part of the tool we also developed a language called Agent Low-Level Language (ALLL), by which agents' behaviour is controlled.

The actual trend in the research of system design aims at an efficiency and safety of developing processes as well as at the quality of resulted systems. There were investigated and developed many methodologies of system design based on models-they are known as Model-Based Design. This paper brings an outline of our approach to Model-Based Design based on the Object Oriented Petri Nets formalism allowing for clear modeling, the possibility to check correctness by simulation techniques as well as by formal verifications.

The importance of formal models used in system design is continually growing. Since various formalisms are suitable for different kinds of systems, their combination is valuable in description of complex systems. The paper deals with a combination of Object Oriented Petri Nets (OOPN) and DEVS formalisms. DEVS is rather static formalism using explicit component interconnections, while OOPN is a highly dynamic formalism with implicit inter-object relations. Although these formalisms are different, both are state-centered and, thus, their integration is well-feasible. The resulting framework derives benefits from both formalisms.

Software engineering is a science discipline dealing with methods and techniques of the system design. Increasing complexity of developed systems makes the design process more exacting. The need for better quality of the development processes is growing up too. As an answer to these requirements, new software engineering methods are raising. They are commonly known as Model-Driven Software Development or Model-Based Design (MBD). An important feature of these methods is the fact that they use executable models, for instance, the most popular one is Object Management Group's Model Driven Architecture (MDA) based on Executable UML. The development methods allow for semi-automatic translation of checked models to implementation language (i.e. the code generation). Unfortunately, the resulting code is not final, the code is supposed to be adapted and these changes are usually not moved back to models. Consequently, the models can become outdated and in most cases loose their value-models do not correspond to the final implementation, possible changes are more and more demanding and it may consequent less productivity in the complex systems design. We base our approach to the system development on simulation models which have a proper formal background and can be integrated into target application with no need to generate a code. Thus, we start with simulation models but during the development process we are obtaining more and more adequate application. The models we use are based on Object-oriented Petri nets formalism. Presence of models in final implementation opens a possibility to make maintenance and adaptation to changing requirements more productive.

Multi-agent systems are one of the prospect approaches to simplification of complex system development. They introduce a natural abstraction layer on top of autonomous actors. Since multi-agent systems are strongly parallel the appropriate paradigms or tools have to be used. This article will demonstrate the application of our developed kind of high-level Petri nets to the deliberative agent modeling and simulation. This formalism is called Object Oriented Petri Nets (OOPN). It introduces a powerful means for description of concurrency and a high level of system dynamism. Moreover, OOPNs are a part of a framework intended for simulation based design featuring model continuity. It means that a model developed incrementally in a simulated environment can become a part of target applications.

PNtalk is a language and system which combines Petri nets and Smalltalk in a consistent way by introducing Object Oriented Petri Nets. The objective of PNtalk is modeling, simulation, and prototyping. Our current focus is heterogeneous modeling, interoperability and multisimulation. To achieve these goals, an open implementation approach proposing appropriate level of control over selected features of models is adopted. The open implementation of PNtalk is accomplished by its reflective metalevel architecture. Multisimulation is demonstrated by a simple case study.

Modelling and simulation make a wide area of the computer science dealing with research on real world by means of its abstractions and experiments on these abstractions. To describe different aspects of modelled world we can use different paradigms and formalisms. The author's direction of interest has been Object oriented Petri nets (OOPNs) and their usage to modelling, simulations, and prototyping of complex systems. In course of time this interest has converged to the simulation framework intended not only to modelling and simulation of complex and parallel systems but also to making prototypes of those systems. The needs of the simple and clear controlling of features above that complex applications is still growing up. To ensure these needs the open approach which proposes some features to control the internal representations has been introduced. The foundation to expression of open implementation is to provide a general implementation framework making easier design and using open implementations.

PNtalk is a project developing a system which combines Petri nets and Smalltalk in a consistent way by introducing Object Oriented Petri Nets. The objective of PNtalk is modeling, simulation, and prototyping systems. Our current focus is higher level of dynamism and higher level of control over PNtalk features in order to allow heterogeneous modeling and better interoperability with its environment. The most important feature is a possibility of replacing Petri nets by other formalisms in some parts of a model. To achieve these goals, an open approach proposing appropriate level of control over selected features of models is adopted. The open implementation of PNtalk is accomplished by its reflective metalevel architecture.

The PNtalk is a project comprising concurrent language and system based on object-oriented Petri nets (OOPNs). PNtalk benefits from the features of Petri nets (formal nature, suggestive description of parallelism, theoretical background) as well as object-orientedness (abstraction, encapsulation, inheritance, polymorphism, and modularity). The purpose of PNtalk is to model, to simulate, to verify, and to prototype concurrent and distributed systems, including systems with dynamic structure. Needed flexibility and adaptability is accomplished by metalevel architecture of PNtalk system. This paper presents key properties of PNtalk, its metaobject architecture and its metaobject protocol (MOP).

The PNtalk system is a language and tool based on object-oriented Petri nets (OOPNs) that have been developed by our research group at Brno University of Technology. Its purpose is to support modelling and prototyping of concurrent and distributed software systems. PNtalk benefits from the features of Petri nets (formal nature, suggestive description of parallelism, theoretical background) as well as object-orientedness (abstraction, encapsulation, inheritance, polymorphism, and modularity). The PNtalk system was originally designed as a transparent layer on top of a Smalltalk system. The Smalltalk classes and objects are transparently interchangeable with classes and objects described by Petri nets. Nevertheless, the original implementation had some limitations disallowing evolution towards distributed programming and advanced approaches to simulation. This is the reason why we decided to redesign the PNtalk system to employ reflective features of Smalltalk-80 more effectively. Our current prototype has been built up as an open system which can combine different modeling and simulation paradigms of describing models and can also simultaneously support several independent simulations. This article is focused on describing the PNtalk architecture. A simple yet suggestive model will demonstrate how PNtalk can be used for modelling and simulation.