Auto-coding UML statecharts for flight software

Statecharts have been used as a means to communicate behaviors in a precise manner between system engineers and software engineers. Handtranslating a statechart to code, as done on some previous space missions, introduces the possibility of errors in the transformation from chart to code. To improve auto-coding, we have developed a process that generates flight code from UML statecharts. Our process is being used for the flight software on the Space Interferometer Mission (SIM)

Evolvable Integration of Activities with Statecharts

The dynamic behavior of a system can be specified in statecharts,\ud and the activities of the system can be implemented in terms of\ud functions in the C programming language. Later, the statecharts\ud and the activities can be integrated to realize the system that\ud fulfils a given set of requirements.\ud \ud After the integration, the statecharts, the activities, and the\ud requirements are subject to change due to emerging necessities\ud such as bug fixes. Any change to any of these artifacts has a cost\ud in terms of effort, and risk of errors.\ud \ud In this paper, we provide a rigorous analysis of a relevant subset\ud of possible changes to activities, and their associated costs. In\ud addition, we present the overview of our solution to reduce these\ud costs.\u

UML as a system level design methodology with application to software radio

Master'sMASTER OF SCIENC

Embedding object-oriented design in system engineering

The Unified Modeling Language (UML) is a collection of techniques intended to document design decisions about software. This contrasts with systems engineering approaches such as for exampleStatemate and the Yourdon Systems Method (YSM), in which the design of an entire system consisting of software and hardware can be documented. The difference between the system- and the software level is reflected in differences between execution semantics as well as in methodology. In this paper, I show how the UML can be used as a system-level design technique. I give a conceptual framework for engineering design that accommodates the system- as well as the software level and show how techniques from the UML and YSM can be classified within this framework, and how this allows a coherent use of these techniques in a system engineering approach. These ideas are illustrated by a case study in which software for a compact dynamic bus station is designed. Finally, I discuss the consequences of this approach for a semantics of UML constructs that would be appropriate for system-level design

Testing a system specified using Statecharts and Z

A hybrid specification language SZ, in which the dynamic behaviour of a system is described using Statecharts and the data and the data transformations are described using Z, has been developed for the specification of embedded systems. This paper describes an approach to testing from a deterministic sequential specification written in SZ. By considering the Z specifications of the operations, the extended finite state machine (EFSM) defined by the Statechart can be rewritten to produce an EFSM that has a number of properties that simplify test generation. Test generation algorithms are introduced and applied to an example. While this paper considers SZ specifications, the approaches described might be applied whenever the specification is an EFSM whose states and transitions are specified using a language similar to Z

Towards the definition of a pattern sequence for real-time applications using a model-driven engineering approach

Real-Time (RT) systems exhibit specific characteristics that make them particularly sensitive to architectural decissions. Design patterns help integrating the desired timing behaviour with the rest of the elements of the application architecture. This paper reports a pattern story that shows how a component-based design has been implemented using periodic concurrent tasks with RT requirements. This work has been done in the context of the development of robotic applications using a Model-Driven Software Development (MDSD) approach. In this context the model-to-code transformations are designed taking into account both the system requirements and the patterns that satisfy them. MDSD provides the conceptual technology for implementing a pattern-guided transition from component-based models to object-oriented implementations. The results of applying the described story of patterns are shown by an application that initializes, configures and schedules the execution of platform-specific components.This work has been partially supported by the Spanish CICYT Project EXPLORE (ref. TIN2009-08572), and the Fundación Séneca Regional Project COMPAS-R (ref. 11994/PI/09)

Towards the Correctness of Software Behavior in UML: A Model Checking Approach Based on Slicing

Embedded systems are systems which have ongoing interactions with their environments, accepting requests and producing responses. Such systems are increasingly used in applications where failure is unacceptable: traffic control systems, avionics, automobiles, etc. Correct and highly dependable construction of such systems is particularly important and challenging. A very promising and increasingly attractive method for achieving this goal is using the approach of formal verification. A formal verification method consists of three major components: a model for describing the behavior of the system, a specification language to embody correctness requirements, and an analysis method to verify the behavior against the correctness requirements. This Ph.D. addresses the correctness of the behavioral design of embedded systems, using model checking as the verification technology. More precisely, we present an UML-based verification method that checks whether the conditions on the evolution of the embedded system are met by the model. Unfortunately, model checking is limited to medium size systems because of its high space requirements. To overcome this problem, this Ph.D. suggests the integration of the slicing (reduction) technique