#### Filter Results:

#### Publication Year

1982

2010

#### Co-author

#### Key Phrase

#### Publication Venue

Learn More

This paper serves as an introduction to the semantics of the Lustre language. Lustre is a language which is useful for reasoning about systems, and, in particular, about proving some types of properties of the system; though these are not discussed in the paper. This work is of interest to us because it can potentially be the basis for semantics for Uccello… (More)

Invited Paper Twelve years ago, PROCEEDINGS OF THE IEEE devoted a special section to the synchronous languages. This paper discusses the improvements , difficulties, and successes that have occured with the synchronous languages since then. Today, synchronous languages have been established as a technology of choice for modeling, specifying , validating,… (More)

In this paper we define timed regular expressions, an extension of regular expressions for specifying sets of dense-time discrete-valued signals. We show that this formalism is equivalent in expressive power to the timed automata of Alur and Dill by providing a translation procedure from expressions to automata and vice versa. The result is extended to… (More)

We present a layered end-to-end approach for the design and implementation of embedded software on a distributed platform. The approach comprises a high-level modeling and simulation layer (Simulink), a middle-level programming and validation layer (SCADE/Lustre) and a low-level execution layer (TTA). We provide algorithms and tools to pass from one layer… (More)

Synchronous data-flow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory data-flow networks. In particular, these networks are not recursively defined, and obey some kind of "synchronous" constraints (<i>clock calculus</i>). Based on Kahn's… (More)

In this article, we define <i>timed regular expressions</i>, a formalism for specifying discrete behaviors augmented with timing information, and prove that its expressive power is equivalent to the <i>timed automata</i> of Alur and Dill. This result is the timed analogue of Kleene Theorem and, similarly to that result, the hard part in the proof is the… (More)

This paper aims to simplify recent efforts proposed by the Berkeley school in giving a formal semantics to the Ptolemy toolbox. We achieve this by developing a simple and elegant functional theory of de-terministic tag systems that is a generalisation of Kahn Process Network theory (KPN). Our theory extends KPN by encompassing networks of processes labelled… (More)

The Simulink/Stateflow toolset is an integrated suite enabling model-based design and has become popular in the automotive and aeronautics industries. We have previously developed a translator called Simtolus from Simulink to the synchronous language Lustre and we build upon that work by encompassing Stateflow as well. Stateflow is problematical for… (More)

We present a method of translating discrete-time Simulink models to Lustre programs. Our method consists of three steps: type inference, clock inference, and hierarchical bottom-up translation. In the process, we explain and formalize the typing and timing mechanisms of Simulink. The method has been implemented in a prototype tool called S2L, which has been… (More)