Results 1  10
of
30
Almost ASAP Semantics: From Timed Models to Timed Implementations
, 2003
"... In this paper, we introduce a parametric semantics for timed controllers called the Almost ASAP semantics. This semantics is a relaxation of the usual ASAP semantics (also called the maximal progress semantics) which is a mathematical idealization that can not be implemented by any physical devic ..."
Abstract

Cited by 53 (6 self)
 Add to MetaCart
(Show Context)
In this paper, we introduce a parametric semantics for timed controllers called the Almost ASAP semantics. This semantics is a relaxation of the usual ASAP semantics (also called the maximal progress semantics) which is a mathematical idealization that can not be implemented by any physical device no matter how fast it is. On the contrary, any correct Almost ASAP controller can be implemented by a program on a hardware if this hardware is fast enough. We study the properties of this semantics, show how it can be analyzed using the tool HyTech, and illustrate its practical use on examples.
Implementation of timed automata: an issue of semantics or modeling
 In Proc. 3rd Int. Conf. Formal Modelling and Analysis of Timed Systems (FORMATS’05), Lecture Notes in Computer Science
, 2005
"... Abstract. We examine to what extent implementation of timed automata can be achieved using the standard semantics and appropriate modeling, instead of introducing new semantics. We propose an implementation methodology which allows to transform a timed automaton into a program and to check whether t ..."
Abstract

Cited by 33 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We examine to what extent implementation of timed automata can be achieved using the standard semantics and appropriate modeling, instead of introducing new semantics. We propose an implementation methodology which allows to transform a timed automaton into a program and to check whether the execution of this program on a given platform satisfies a desired property. This is done by modeling the program and the execution platform, respectively, as an untimed automaton and a collection of timed automata. We also study the problem of property preservation, in particular when moving to a “better” execution platform. We show that some subtleties arise regarding the definition of “better”, in particular for digital clocks. The fundamental issue is that faster clocks result in better “sampling ” and therefore can introduce more behaviors. 1
Robustness and Implementability of Timed Automata
 In Proc. Joint Conf. Formal Modelling and Analysis of Timed Systems and Formal Techniques in RealTime and Fault Tolerant System (FORMATS+FTRTFT’04), volume 3253 of LNCS
, 2004
"... In a former paper, we de ned a new semantics for timed automata, the Almost ASAP semantics, which is parameterized by to cope with the reaction delay of the controller. We showed that this semantics is implementable provided there exists a strictly positive value for the parameter for which t ..."
Abstract

Cited by 25 (13 self)
 Add to MetaCart
(Show Context)
In a former paper, we de ned a new semantics for timed automata, the Almost ASAP semantics, which is parameterized by to cope with the reaction delay of the controller. We showed that this semantics is implementable provided there exists a strictly positive value for the parameter for which the strategy is correct. In this paper, we de ne the implementability problem to be the question of existence of such a . We show that this question is closely related to a notion of robustness for timed automata de ned in [Pur98] and prove that the implementability problem is decidable.
The Challenges of Building Advanced Mechatronic Systems Future of Software Engineering(FOSE'07)
"... Montreal. He also spent four years in industry as head of the R&D department of a mediumsize software house. His research interests are in objectoriented specifications for embedded systems, software processes, and reengineering. He was program cochair of the 23rd ..."
Abstract

Cited by 20 (2 self)
 Add to MetaCart
(Show Context)
Montreal. He also spent four years in industry as head of the R&D department of a mediumsize software house. His research interests are in objectoriented specifications for embedded systems, software processes, and reengineering. He was program cochair of the 23rd
Robust Safety of Timed Automata
 FORMAL METHODS IN SYSTEM DESIGN
"... Timed automata are governed by an idealized semantics that assumes a perfectly precise behavior of the clocks. The traditional semantics is not robust because the slightest perturbation in the timing of actions may lead to completely different behaviors of the automaton. Following several recent wo ..."
Abstract

Cited by 16 (8 self)
 Add to MetaCart
Timed automata are governed by an idealized semantics that assumes a perfectly precise behavior of the clocks. The traditional semantics is not robust because the slightest perturbation in the timing of actions may lead to completely different behaviors of the automaton. Following several recent works, we consider a relaxation of this semantics, in which guards on transitions are widened by ∆> 0 and clocks can drift by ε> 0. The relaxed semantics encompasses the imprecisions that are inevitably present in an implementation of a timed automaton, due to the finite precision of digital clocks. We solve the safety verification problem for this robust semantics: given a timed automaton and a set of bad states, our algorithm decides if there exist positive values for the parameters ∆ and ε such that the timed automaton never enters the bad states under the relaxed semantics.
Timetriggered Implementations of Dynamic Controllers
, 2012
"... Bridging the gap between modelbased design and platformbased implementation is one of the critical challenges for embedded software systems. In the context of embedded control systems that interact with an environment, a variety of errors due to quantization, delays, and scheduling policies may ge ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
Bridging the gap between modelbased design and platformbased implementation is one of the critical challenges for embedded software systems. In the context of embedded control systems that interact with an environment, a variety of errors due to quantization, delays, and scheduling policies may generate executable code that does not faithfully implement the modelbased design. In this paper, we show that the performance gap between the modellevel semantics of linear dynamic controllers, e.g. the proportionalintegralderivative (PID) controllers, and their implementationlevel semantics can be rigorously quantified if the controller implementation is executed on a predictable timetriggered architecture. Our technical approach uses lifting techniques for periodic, timevarying linear systems in order to compute the exact error between the model semantics and the execution semantics. Explicitly computing the impact of the implementation on overall system performance allows us to compare and partially order different implementations with various scheduling or timing characteristics.
Modular Code Generation from Hybrid Automata Based on Data Dependency
 In Proceedings of the 9th IEEE RealTime and Embedded Technology and Applications Symposium
, 2003
"... Modelbased automatic code generation is a process of converting abstract models into concrete implementations in the form of a program written in a highlevel programming language. The process consists of two steps, first translating the primitives of the model into (approximately) equivalent imple ..."
Abstract

Cited by 12 (7 self)
 Add to MetaCart
(Show Context)
Modelbased automatic code generation is a process of converting abstract models into concrete implementations in the form of a program written in a highlevel programming language. The process consists of two steps, first translating the primitives of the model into (approximately) equivalent implementations, and then scheduling the implementations of primitives according to the data dependency inherent in the model. When the model is based on hybrid automata that combine continuous dynamics with a finite state machine, the data dependency must be viewed in two aspects: continuous and discrete. Continuous data dependency is present between mathematical equations modeling timecontinuous behavior of the system. On the other hand, discrete data dependency is present between guarded transitions that instantaneously change the continuous behavior of the system. While discrete data dependency has been studied in the context of code generation from modeling languages with synchronous semantics (e.g., ESTEREL), there has been no prior work that addresses both kinds of dependency in a single framework. In this paper, we propose a code generation framework for hybrid automata which deals with continuous and discrete data dependency. We also propose techniques for generating modular code that retains modularity of the original model. The framework has been implemented based on the hybrid system modeling language CHARON, and experimented with Sony's robot platform AIBO.
Generating optimized code from scr specifications
 Proceedings of LCTES 2006: ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems
, 2006
"... A promising trend in software development is the increasing adoption of modeldriven design. In this approach, a developer first constructs an abstract model of the required program behavior in a language, such as Statecharts or Stateflow, and then uses a code generator to automatically transform th ..."
Abstract

Cited by 11 (7 self)
 Add to MetaCart
(Show Context)
A promising trend in software development is the increasing adoption of modeldriven design. In this approach, a developer first constructs an abstract model of the required program behavior in a language, such as Statecharts or Stateflow, and then uses a code generator to automatically transform the model into an executable program. This approach has many advantages—typically, a model is not only more concise than code and hence more understandable, it is also more amenable to mechanized analysis. Moreover, automatic generation of code from a model usually produces code with fewer errors than handcrafted code. One serious problem, however, is that a code generator may produce inefficient code. To address this problem, this paper describes a method for generating efficient code from SCR (Software Cost Reduction) specifications. While the SCR tabular notation and tools have been used successfully to specify, simulate, and verify numerous embedded systems, until now SCR has lacked an automated method for generating optimized code. This paper describes an efficient method for automatic code generation from SCR specifications, together with an implementation and an experimental evaluation. The method first synthesizes an executionflow graph from the specification, then applies three optimizations to the graph, namely, input slicing, simplification, and output slicing, and then automatically generates code from the optimized graph. Experiments on seven benchmarks demonstrate that the method produces significant performance improvements in code generated from large specifications. Moreover, code generation is relatively fast, and the code produced is relatively compact.
Reusable Idioms and Patterns in Graph Transformation Languages
 PROC. ET AL. 2ND INTERNATIONAL WORKSHOP ON GRAPH BASED TOOLS (GRABATS 2004). SATELLITE WORKSHOP OF ICGT 2004
, 2004
"... Software engineering tools based on Graph Transformation techniques are becoming available, but their practical applicability is somewhat reduced by the lack of idioms and design patterns. Idioms and design patterns provide prototypical solutions for recurring design problems in software engineerin ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
(Show Context)
Software engineering tools based on Graph Transformation techniques are becoming available, but their practical applicability is somewhat reduced by the lack of idioms and design patterns. Idioms and design patterns provide prototypical solutions for recurring design problems in software engineering, but their use can be easily extended into the graph transformation systems. In this paper we briefly present a simple graph transformations language: GREAT, and show how typical design problems that arise in the context of model transformations can be solved using its constructs. These solutions are similar to software design patterns, and intend to serve as the starting point for a more complete collection.