Marco A. Wehrmeister

An Aspect-Oriented Approach for Dealing with Non-Functional Requirements in a Model-Driven Development of Distributed Embedded Real-Time Systems

This work presents a proposal to use aspect orientation in the analysis and design of distributed embedded real-time systems (DERTS). These systems have several requirements directly related to their main characteristics, the so-called non-functional requirements (NFR), which refer to orthogonal properties, conditions, and restrictions that are spread out over the entire system. Pure object-oriented methods do not address successfully those so called cross-cutting concerns, so new technologies, like aspect orientation, are applied in order to fulfill this gap. The paper presents DERAF istributed embedded real-time aspects framework, an extensible and high-level framework (i.e. implementation-independent) to handle NFR of DERTS at earlier design stages. DERAF combines the use of aspects with RT-UML, aiming to separate the handling of non-functional from functional requirements in the model driven design of DERTS. The paper presents the use of DERAF on a case study of an unmanned air vehicle (UAV)

DERAF: a high-level aspects framework for distributed embedded real-time systems design

Distributed Embedded Real-time Systems (DERTS) have several requirements directly related to characteristics that are difficult to handle when a pure object-oriented method is used for their development. These requirements are called Non-Functional Requirements (NFR) and refer to orthogonal properties, conditions, and restrictions that are spread out over the system. Pure object-oriented methods do not address successfully those concerns, so new technologies, like aspect orientation, are being applied in order to fulfill this gap. This work presents a proposal to use aspect orientation in the analysis and design of DERTS. To support our proposal, we created DERAF (Distributed Embedded Real-time Aspects Framework), an extensible high-level framework (i.e. implementation-independent) to handle NFR of DERTS. DERAF is used together with RT-UML in the design phase, aiming to separate the handling of non-functional from functional requirements in the Model Driven Design of DERTS. A qualitative assessment of DERAF separation of concerns is also presented.

GenERTiCA: A Tool for Code Generation and Aspects Weaving

Model-driven design (MDD) can be perceived in the recent literature as an option to deal with the increasing complexity of the design of distributed embedded real-time systems (DERTS). This paper reports some results of a research project aiming to support a MDD approach, which applies concepts of the aspect-oriented (AO) paradigm in order to improve the treatment of non-functional requirements (NFR) in the design of DERTS. A tool named GenERTiCA, which generates source code from UML diagrams and also weaves aspect adaptations, has been developed to support such MDD/AO approach. This paper presents results regarding the use of GenERTiCA to generate code and implement aspects (from a high-level framework of aspect) for the RT-FemtoJava platform, a RTSJ-based and optimized Java platform for DERTS.

Aspect-Oriented Model-Driven Engineering for Embedded Systems Applied to Automation Systems

Automation and control systems include many “intelligent” automation devices, which are usually implemented as complex embedded systems. New methods and tools are demanded to cope with the increasing design complexity, while keeping the project on schedule. Proper handling of nonfunctional system requirements is a key factor during the design of industrial automation systems, since in some application domains they are as important as (sometimes, more important than) functional requirements. This paper presents a model-driven engineering approach, which combines Unified Modeling Language (UML) and aspect-oriented software development (AOSD) to design real-time and embedded automation systems. The proposed approach allows a smooth transition from the initial phases to implementation by using software tools, comprising the system specification and the automatic generation of source code. By combining UML with model-level aspects and a script-base code generation tool, it enables the use of AOSD during system design and implementation, even though the target platform does not natively support such concepts. Experimental results on using this approach to design real-world examples of automation systems are presented. The results indicate a positive impact on the design of automation systems. The encapsulation of nonfunctional requirements was improved, increasing the reuse of developed artifacts. Generated source code statistics indicate that the proposed approach can generated a fair amount of code per model element.

Optimizing Real-Time Embedded Systems Development Using a RTSJ-Based API

Over the last years, Java gained popularity as a suitable programming language for embedded real-time systems. This popularity influenced the definition of the Real-Time Specification for Java (RTSJ), which constitutes a high-level programming interface for creating real-time applications using Java. The current work presents an API based on the RTSJ that optimizes real-time embedded systems development. Using the provided API, programmers can make use of high-level mechanisms to represent concurrency and timing constraints in their Java applications. The developed application can be further synthesized to a Java processor. The paper illustrates the use of the proposed API by means of a case study that implements a crane control system. This case study highlights the benefits and advantages on using the proposed API.

Optimizing the Generation of Object-Oriented Real-Time Embedded Applications Based on the Real-Time Specification for Java

The object-oriented paradigm has become popular over the last years due to its characteristics that help managing the complexity in computer systems design. This feature also attracted the embedded systems community, as todays embedded systems need to cope with several complex functionalities as well as timing, power, and area restrictions. Such scenario has promoted the use of the Java language and its real-time extension (RTSJ) for embedded real-time systems design. Nevertheless, the RTSJ was not primarily designed to be used within the embedded domain. This paper presents an approach to optimize the use of the RTSJ for the development of embedded real-time systems. Firstly, it describes how to design real-time embedded applications using an API based on RTSJ. Secondly, it shows how the generated code is optimized to cope with the tight resources available, without interfering in the mandatory timing predictability of the generated system. Finally it discusses an approach to synthesize the applications on top of affordable FPGAs. The approach used to synthesize the embedded real-time system ensures a bounded timing behavior of the object-oriented aspects of the application, like the polymorphism mechanism and read/write access to objects data fields

Reflective middleware for heterogeneous sensor networks

The use of sensor networks in sophisticated applications is emerging as a new trend. However, the integration and coordination of heterogeneous sensors is still a challenge, especially when the target application scenario is susceptible to constant changes. Such systems must adapt themselves in order to fulfill requirements that can also change during the system runtime. Moreover, the changes that occur in such scenarios require services located at different places during the system runtime. Due to the dynamicity of this context, system adaptations must take place very quickly, requiring that decisions for adaptation are taken autonomously by the system without waiting for human operators directions. Thus a reflective behavior must be provided. This paper presents a reflective middleware that supports reflective behaviors to address adaptation needs of heterogeneous sensor networks deployed in dynamic scenarios. This middleware presents specific handling of concerns related to real-time, service adaptation and resource allocation through network reasoning. These concerns are addressed mainly by the use of mobile and multi-agents, and aspect-oriented concepts. The use of multi-agents represents the spreading of intelligence over the network, while the mobile-agents provide service adaptation by code mobility. In the same direction, aspects address behavioral adaptations related to crosscutting concerns.

Using Aspect-Oriented Concepts in the Requirements Analysis of Distributed Real-Time Embedded Systems

Distributed Real-time Embedded (DRE) systems commonly have several requirements that are difficult to handle when a pure object-oriented method is used for their development. These requirements are called non-functional requirements and refer to orthogonal properties, conditions, and restrictions that are spread out over the system. In general, the specification of those requirements using pure object oriented methods leads to intermixed specification with the functional requirements. This work presents a proposal to use the concepts of aspect orientation in the specification of DRE requirements at the system analysis phase, offering a link from those requirements to system elements in the design phase. To support our proposal, it was performed an adaptation of a method called FRIDA (From RequIrements to Design using Aspects) to the DRE generating the RT-FRIDA

An Infrastructure for UML-Based Code Generation Tools

The use of Model-Driven Engineering (MDE) techniques in the domain of distributed embedded real-time systems are gain importance in order to cope with the increasing design complexity of such systems. This paper discusses an infrastructure created to build GenERTiCA, a flexible tool that supports a MDE approach, which uses aspect-oriented concepts to handle non-functional requirements from embedded and real-time systems domain. GenERTiCA generates source code from UML models, and also performs weaving of aspects, which have been specified within the UML model. Additionally, this paper discusses the Distributed Embedded Real-Time Compact Specification (DERCS), a PIM created to support UML-based code generation tools. Some heuristics to transform UML models into DERCS, which have been implemented in GenERTiCA, are also discussed.

MDA-based approach for embedded software generation from a UML/MOF repository

This work presents a UML/MOF meta-modeling infrastructure, following the MDA approach, which is oriented to the design space exploration of embedded systems, based on the independent specification of application and platform. A mapping from the application into the platform is implemented by model transformations. A meta-data repository implementation is also introduced, automatically providing an Application Programming Interface (API) that is suitable to the manipulation of the UML meta-models and models and to the implementation of design tools for embedded systems. In order to illustrate the applicability of these resources, a source code generation tool for embedded software has been implemented and applied in a concrete case study.