J. van Katwijk

A software process for the construction of predictable on-board embedded real-time systems

The rise of the ‘cheaper, faster, better’ mission paradigm increasingly challenges the industrial development of satellite systems. The novel paradigm will have a profound impact on the production of the real‐time software embedded on board new‐generation systems. This paper contends that a large proportion of the ensuing demands can be satisfied by an iterative and incremental development model revolving around two evolutionary enhancements to the present engineering approach, namely (1) static real‐time analysis as a key ingredient of the software verification process, and (2) an architectural paradigm centred on fixed priority preemptive scheduling. Copyright

Hybrid specification of control systems

An alternative approach to the development of control systems is presented. It differs from current ones in two aspects, because it is based on a formal software specification language, which allows formal verification and because it enables multidisciplinary development of a control system as existing control models can be easily incorporated in the discussed approach. Simulation of ASTRAL specifications is discussed. Simulation, as opposed to verification which is laborious, is useful to provide a quick impression of possible system behaviors. It is shown how existing (continuous) control models, like those constructed using software packages like MatLab, can be incorporated in an ASTRAL specification thus leading to a hybrid specification containing both continuous and discrete subsystems. This hybrid style of specification is illustrated by the example of a robot control system. The specification language and some aspects of control theory are discussed in the introduction. In the second section the example specification concerning robot control and incorporation of continuous system models is discussed. Simulation of the specification is addressed in the third section. The final section presents conclusions and suggestions for future work.

Specification of Real-Time Systems in UML

We introduce time semantics into UML class and statechart diagrams. This extends the expressiveness of UML for specification of real-time systems and allows to specify verification properties of real-time systems by means of Timed Computation Tree Logic. We furthermore propose a way to collect stereotypes for specification of real-time systems. The approach is illustrated by a case study.

A timed automata semantics for real-time UML specifications

We introduce extensions of the UML class, object and statechart diagrams and define the semantics of the UML extensions by means of extended timed graphs (XTG), a timed automata variant. This approach opens the possibility to specify properties of the UML specifications using the timed computation tree logic. The transformation of the UML-specification into XTG allows the verification the system by model checking using the LPMC model checker tool, which uses XTG as its input language.

Asynchronous transfer of control in Ada

<italic>Rapid event driven mode shifts and certain kinds of error recovery require a task asynchronously to affect the flow of control of another task in ways that cannot be conveniently achieved by abort alone….</italic>

SEAL: a simple language for prototyping action-event specifications

Abstract According to e.g. Parnas [1], reactive systems can be modeled very conveniently using an action-event paradigm. According to this paradigm a system is assumed to be build around a state, events causing the system to modify this state. In this paper we describe a simple language, SEAL, (SEAL is an acronym for Seal: an Experimental Action-event Language) for prototyping systems which have been described in the form of action-event specifications. The language has been used for modelling some simple problems; our current activities encompass an improved implementation that allows some analysis on the statical program text.

SEPDS: a support environment for prototyping distributed systems

The SEPDS system is an engineering framework for experimentation and prototyping. It is intended to provide a cohesive and integrated set of tools to support the design process and profiling of distributed systems. The architecture of the SEPDS system, based on an object-oriented prototyping approach, is described. The underlying concept and the separate system components are also described. The prototyping of distributed systems encompasses such considerations as parallelism, object grain size, and communication and synchronization overhead. The computing power of the available processors is exploited. The features and advantages of the SEPDS system are discussed, emphasizing the features closely related to the distributed system simulation and profiling. The current status of the project and directions for future work are also discussed.<<ETX>>

Addressing types and objects in Ada

In this paper a new model is presented for the run‐time description of arrays, records, and other data types in Ada*‐like programming languanges. The model has several advantages over the classical implementation model using dope vectors. It has been used for the run‐time description of data strutures in an implementation of almost the whole Ada programming languange.In this paper a new model is presented for the run-time description of arrays, records, and other data types in Ada*-like programming languanges. The model has several advantages over the classical implementation model using dope vectors. It has been used for the run-time description of data strutures in an implementation of almost the whole Ada programming languange. First an outline of our data description model is presented, then issues in addressing components of composite objects are discussed. A practical approach to implement the model is discussed next and finally an example is given and some conclusions are drawn.

Ada 95 as implementation vehicle for formal specifications

A main concern in the initial phases of the development of a system to be built is capturing the system requirements and expressing them as an adequate model, either formal or informal. In subsequent phases of the development of the system this model is used as reference for transformation steps. In this paper we describe a reasonably successful experimental strategy for the implementation of real-time systems, starting from a formal specification, resulting in an Ada 95 implementation of the system and we evaluate the approach based upon practical experiences.

Applying software engineering principles in train control systems

In the development of controllers for complex real-time systems the need for an adequate specification and design methodology arises. The use of a viewpoint-oriented methodology for the design and specification of real-time systems is applied in a case study, the development of a train control system. The method expresses the requirements to be put on the system by taking into account five different viewpoints. Each view is expressed using existing techniques. The design methodology shows to be applicable to the development of train control systems because it addresses aspects like timing constraints, safety and availability issues of such systems. This paper deals with designing a train control system by adopting a viewpoint-oriented methodology. It is aimed at a correct specification and design of the train control system.<<ETX>>