Óscar R. Ribeiro

Model checking embedded systems with PROMELA

The design process for embedded systems can benefit from the usage of formal methods, if some properties of the systems are checked, before design and implementation decisions are accomplished. This paper presents a model checking approach using the Spin tool, to verify some important properties of embedded systems, namely liveness, deadlock-freedom, and structural conflicts among transitions. The systems are modelled with a variant of Petri nets, called SIPN (synchronous and interpreted Petri nets), and this paper discusses how SIPN models should be specified with the PROMELA language (input format for the Spin model checker). The approach is exemplified with a case study.

Translating Synchronous Petri Nets into PROMELA for Verifying Behavioural Properties

For developing embedded systems, the design process may benefit in some contexts from the usage of formal methods, namely to find critical errors and flaws, before final design and implementation decisions are taken. The Synchronous and Interpreted Petri net (SIP-net) modelling language is considered in this article to model embedded systems. This model of computation is based on safe Petri nets with guarded transitions and synchronous transitions firing, and also includes enabling and inhibitor arcs. The Spin tool, whose input language is PROMELA, is a verification system based on model checking techniques. This article presents a program to translate SIP-net models into PROMELA code and discusses in detail the adequacy of the created PROMELA specification for verification through model checking techniques.

The APEX framework: prototyping of ubiquitous environments based on Petri nets

The user experience of ubiquitous environments is a determining factor in their success. The characteristics of such systems must be explored as early as possible to anticipate potential user problems, and to reduce the cost of redesign. However, the development of early prototypes to be evaluated in the target environment can be disruptive to the ongoing system and therefore unacceptable. This paper reports on an ongoing effort to explore how model-based rapid prototyping of ubiquitous environments might be used to avoid actual deployment while still enabling users to interact with a representation of the system. The paper describes APEX, a framework that brings together an existing 3D Application Server with CPN Tools. APEX-based prototypes enable users to navigate a virtual world simulation of the envisaged ubiquitous environment. The APEX architecture and the proposed CPN-based modelling approach are described. An example illustrates their use.

Validation of Scenario-Based Business Requirements with Coloured Petri Nets

A scenario can be used to describe a possible instantiation of a given business use case and can be expressed for example as a list of steps written in natural language, or by an interaction diagram. This paper discusses how a collection of scenarios, all expressed as UML2 sequence diagrams, can be described for validation purposes by a single model, written in the Coloured Petri Nets (CPN)modelling language. Due to the support for parallelism given by the CPN language, the obtained CPN model can: (1) simultaneously execute several scenarios; and (2) elegantly represent the parallel activities inside a scenario. This two-level parallelism is crucial during validation, since it allows one to detect problems that are only evident when several scenarios are in simultaneous execution and may affect each other. We exemplify our approach in a system that has a rich set of interactions with its users.

Validation of Reactive Software from Scenario-Based Models

This thesis proposal suggests a model-based approach to obtain, from a set of behavioural scenarios of a given reactive software system, a graphical animation for reproducing that set of scenarios for validation purposes. The approach assumes that the requirements of the system are described by a use case diagram, being the behaviour of each use case detailed by a collection of scenario descriptions. These use cases and scenarios are transformed into a Coloured Petri Net (CPN) model, which is next complemented with animation-specific elements. By executing the CPN model, it is possible to animate the scenarios in a user-friendly way and thus ensuring an effective involvement of the users in the systems validation. The CPN model is enforced to be (1) parametric, allowing an easy modification of the initial conditions of the scenarios, (2) environment-descriptive, meaning that it includes the state of the relevant elements of the environment, and (3) animation-separated, implying that the elements related to animation are clearly separated from the other ones. We validate our approach based on its application to two examples of reactive systems.

An agile software product line model-driven design environment for video surveillance systems

This paper describes an agile model-driven generative software development paradigm supported by mainstream tools to offer a significant leverage in hiding commonalities and configuring variabilities across families of video surveillance products while maintaining the new product quality. The integration of Agile and SPL (Software Product Line) paradigms is promoted to develop video surveillance systems as a pay-as-you-go fashion rather than developing an ex-nihilo new product, despite the perceived incompatibilities of these paradigms and potential challenges of such integration.

Model-driven template metaprogramming

The development and maintenance of hardware/software Systems with a high level of variability is a complex task. At IVV Automacão, LDA the video surveillance system is implemented as a software product line that exploit the common component features that compose the video surveillance system family of products. In order to manage the system variability at code level, the IVV developers use C++ template metaprogramming (TMP). Although, TMP presents advantages in variability code management at compile time, the syntax and idioms of TMP are esoteric compared to conventional C++ programming, and TMP can be difficult to understand. In this paper we propose a novel approach to implement and maintain TMP code using a model-driven tool, that employs Template Markup Language with a XSLT transformer to automatic generate and maintain TMP code.