Increasing complexity of real-time systems, and demands for enabling their configurability and reusability are strong motivations for applying new software engineering principles, such as aspect-oriented and component-based development. In this paper we introduce a novel concept of aspectual component-based real-time system development. The concept is based on a design method that assumes decomposition of real-time systems into components and aspects, and provides a real-time component model that supports the notion of time and temporal constraints, space and resource management constraints, and composability. Initial results show that the successful application of the proposed concept has a positive impact on real-time system development in enabling efficient configuration of real-time systems, improved reusability and flexibility of real-time software, and modularization of crosscutting concerns. We provide arguments for this by presenting an application of the proposed concept on the design and development of a configurable embedded real-time database, called COMET. Furthermore, using the COMET system as an example, we introduce a novel way of handling concurrency in a real-time database system, where concurrency is modeled as an aspect crosscutting the system.

This paper presents an approach for avoiding this difficulty. It demonstrates the approach by showing its application to parts of a real software development.

The Unified Modeling Language (UML) statechart diagram is used for modeling the dynamic aspects of systems. The UML statechart diagrams include many concepts that are not present in most popular programming languages, like Java or C++. There exists a gap between high level modeling language and a programming language. There is not a one-to-one mapping between a statechart and its implementation. Most of the approaches for implementing UML statecharts diagram either suffer from maintenance problems or implement only a subset of UML statecharts. This paper proposes an approach to generate readable, efficient and compact executable code from the UML statechart diagram in an object-oriented (OO) language like Java using design patterns. By representing states as objects, we extend the state design pattern to implement the hierarchical states using the concept of object composition and delegation. We also propose an approach to implement signal and time events, guards and branches and internal transitions. The proposed approach makes elegant handling of most of the statechart features.

Joint angle determination for robots with flexible links can be difficult. Inertial orientation tracking combined with RF positioning provides an accurate method for determining end effector orientation and location. The same technology could also be used to determine human posture for the purpose of inserting humans in synthetic environments. Orientation filters based upon Euler angles suffer from singularities. This paper describes the design, implementation, and preliminary testing of an inertial tracking system using a "complementary" filter based upon quaternions. This filter is capable of tracking a rigid body through all orientations and is more efficient than those based on Euler angles. Results of qualitative tests of a prototype inertial angle tracking device are presented. Background Precise control of a robot manipulator requires accurate determination of end effector location and orientation. Due to link flexing and bending, this is often difficult. This problem could be...

We propose refinement laws for the top level design elements of Real Time UML (UML-RT): classes and capsules. These laws can be used to develop concrete design models from abstract analysis models. Laws for introducing and decomposing classes and capsules are presented. Standard data refinement techniques are adapted for classes, and process refinement techniques for capsules. We also propose techniques for behavioural inheritance of classes and capsules. Soundness is briefly addressed by relating UML-RT elements to OhCircus, a formal unified language of classes and processes. To illustrate the overall strategy, we develop a detailed design of an operating system resource scheduler from a high-level analysis model.

An open distributed control system (DCS), which consists of many devices and an open network interconnecting them, is now used in many automation areas. For assuring the control performance under the heavy traffic on the network, the simulation of a DCS is strongly needed. For this purpose, we propose an objectoriented design pattern approach as a uniform, efficient and accurate method of modeling and simulating a DCS. Four design patterns are newly proposed. DeviceConstructor describe classes and mechanisms for uniformly structuring device models composed of many kinds of sensors and actuators. Statechart pattern defines classes and the state-transition execution mechanism for realizing the behavior of sensors and actuators in a device. While Event-Chain pattern defines classes and the event intra-device and inter-device. The systematic implementation procedures from these patterns to the executable Java code of the DCS simulation model are also discussed. Finally, the effectiveness of our approach was proved by developing the Java-based DCS modeler and simulator used in building automation area.

ABSTRACT: Within the AIDA project a modelling framework has been developed to support design issues related to the implementation of control applications in embedded distributed computer systems. At a relatively high level of abstraction the models describe the structure and timing behaviour of a control application (in terms of functions and operational modes) and its implementation (hardware, operating system threads and resources). The resource description allows the timing behaviour of the implementation to be analysed and fed back into the application models. The models form the basis for a decentralization tool-set, where a first prototype is under development. Examples of the models are given and the framework is compared to related modelling approaches. 1.

Separation of Concerns separates requirements such as synchronization and scheduling from the core functionality of the software system. These requirements are often referred to as crosscutting concerns. The implementation of such requirements is scattered throughout the software system, which results in the code-tangling problem Aspect Oriented Programming provides the user with the ability to modularize, and weave the representation of crosscutting concerns in order to maximize code reusability and solves the code-tangling problem. Using the Unified Modeling Language (UML) to model and inter-weave these crosscutting concerns is an area thast is getting more attension from researchers, and is the theme of this paper. In this paper we present a formal design methodology to model the system's concerns based on aspect-orientation. We show how to model and interweave the different sub-models that represent different concerns using UML's Statecharts and Class Diagrams. In Addition our initial study shows that our approach demonstrates the benefits for aspect-oriented modeling, like maintainability, reusability and trace-ability at the design phase as well as at the implementation phase of the development life cycle.

risk analysis, risk modeling, componentdependency graphs, software architecture, dynamic metrics Risk assessment is an essential process of every software risk management plan. Several risk assessment techniques are based on the subjective judgement of domain experts. Subjective risk assessment techniques are human intensive and error-prone. Risk assessment should be based on product attributes that we can quantitatively measure using product metrics. This paper presents a methodology for reliability risk assessment at the early stages of the development lifecycle, namely the architecture level. We describe a heuristic risk assessment methodology that is based on dynamic

Network hardware design is becoming increasingly challenging because more and more demands are put on network bandwidth and throughput requirements, and on the speed with which new devices can be put on the market. Using current standard techniques (general purpose microprocessors, ASIC's) these goals are difficult to reach simultaneously. One solution to this problem that has recently attracted interest is the design of programmable processors with network-optimized hardware, that is, network or protocol processors. In this paper a simulation framework for a family of TTA protocol processor architectures is proposed. The protocol processors consist of a number of buses with functional units that encapsulate protocol specific operations. The TACO protocol processor simulator is a C++ framework based on SystemC. Functional units are created as C++ classes, which makes it easy to experiment with different configurations of the processor to see its performance.