Context-awareness Meta-model for Reconﬁgurable Control Systems

Soumoud Fkaier

1, 2, 3

, Mohamed Romdhani

, Mohamed Khalgui

1, 2

and Georg Frey

Polytechnic School of Tunisia, Carthage University, Tunisia

LISI Lab. of INSAT, Carthage University, Tunisia

Automation and Energy Systems, Saarland University, Germany

Keywords:

Meta-model, Reconﬁguration, Real-time System, Software Architecture, Adaptive System, Functional

Constraint.

Abstract:

With the increasing evolution of adaptive control systems, control applications are asked to satisfy more con-

straints. On one hand, these applications have to guarantee ﬂexible adaptation processes. On the other hand,

they must offer an efﬁcient interaction with the environment. Satisfying such needs is still challenging due to

real-time requirements. Developing an application covering these constraints needs a robust software support.

Some properties like clear structuring, ﬂexibility and reuse are becoming necessary to ease the development

of the appropriate applications. In this paper, we propose a context-aware meta-model enabling the devel-

opment of real-time reconﬁgurable control systems. This meta-model offers a development ﬂexibility while

meeting the functional as well as the real-time constraints. To prove the efﬁciency of this meta-model, we

implemented a framework on the basis of the new concepts. Also, we simulated a case study using the new

tool. As a performance test, we calculated the system response time and we compared it with other work.

1 INTRODUCTION

Adaptive control systems are systems that provide

the possibility to adapt their behavior to the eventual

changes (Lepuschitz et al., 2011). The main feature

that distinguishes them is leading self-reconﬁguration

(Valentini et al., 2013). Reconﬁguration scenarios are

dedicated to allow adding, removing and/or updating

some system tasks at the aim to keep its effective-

ness (Idriss et al., 2015). Reconﬁgurations can have

various origins: They can be caused by changes in

the control targets, the state of the system and even

the environment that the system behaves within (Ca-

linescu et al., 2011). In this paper we focus on devel-

oping reconﬁgurations coming from the environment.

We consider that this issue can be treated based on

context-awareness paradigm. This concept has dealt

at ﬁrst with the ﬁeld of mobile computing. It was in-

troduced by (Schilit and Theimer, 1994) as a solution

for mobile applications to enable the adaptation to the

location, nearby users/objects, and modiﬁcations of

those objects at run-time. After that, the notion has

been boosted and it was developed in a wide range of

ﬁelds: Internet of Things (Sukode et al., 2015), health

care systems (Lo et al., 2011), transportation systems

(Al-Sultan et al., 2013), and many other ﬁelds (Zhang

et al., 2013) (Zhan et al., 2014)(Schuller et al., 2013).

One important promising ﬁeld of study is improving

the control systems by providing them with the ap-

titude to adjust their execution according to the dy-

namic changes of the environment.

To be useful, a reconﬁgurable system has to meet

some constraints. One common challenge of the most

of the adaptive systems is respecting real-time re-

strictions. These systems are considered meaning-

ful unless they do not exceed the deadlines of their

tasks. Hence, satisfying real-time constraints is pri-

marily needed. Furthermore, ensuring a certain level

of awareness about what happens in the environment

is of great importance. So, these systems are asked

to be ﬂexible enough in order to lead ﬂuent reconﬁg-

urations. Also, they are inquired to pick-up as max-

imum as possible the occurred events in their prox-

imity. Moreover, treating reconﬁgurations at runtime

is not a trivial task since there are some events that

can be contradictious or that may need some shared

resources. The system services must be executed re-

specting the dependencies relations. As can be seen,

there are various constraints to be fulﬁlled. Develop-

ing such systems will be really a hard or even a com-

plex task. In that case, to avoid design complexity a

high-level of abstraction becomes a necessity.

226

Fkaier, S., Romdhani, M., Khalgui, M. and Frey, G.

Context-awareness Meta-model for Reconﬁgurable Control Systems.

DOI: 10.5220/0006328502260234

In Proceedings of the 12th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE 2017), pages 226-234

ISBN: 978-989-758-250-9

Our contribution in this paper, is to offer a new

modeling concept of real-time context-aware recon-

ﬁgurable systems. We propose a context-aware meta-

model allowing the speciﬁcation of such system in an

easy way. The proposed meta-model aim to guarantee

the interaction with the environment and the aware-

ness about the context of the use. It offers the respect

of real-time as well as the functional constraints of

the system. Also, it offers a ﬂexibility of the recon-

ﬁguration processes. In addition, we implemented a

framework using C# programming language. We sim-

ulated a formal case study with the developed tool.

We calculated the system response time to prove the

efﬁciency of the new meta-model and we compared

the results to another work.

The remainder of this paper is given as follows:

Section 2 presents brieﬂy the background of our

proposition. Section 3 contains the deﬁnition and

modeling of the new meta-model. Section 4 presents

the application to the case study. Finally, Section 5

concludes this paper and highlights the perspectives.

2 BACKGROUND

Numerous works have provided speciﬁcations facil-

itating the development of adaptive control systems

(Siddiqi and de Weck, 2008). In the following, we

brieﬂy show some works on modeling of real-time

reconﬁgurable systems. (Capilla et al., 2011) have

proposed an UML meta-model to be able to capture

decisions. They focused on some important issues

such as maintenance, evolution and run-time deci-

sions. (Feiler et al., 2006) proposed the Architecture

Analysis and Design Language (AADL) which is an

architecture description language allowing the spec-

iﬁcation of both software and hardware of a system.

It offers specifying reconﬁgurable systems using state

machines in which the state represents a conﬁguration

and a transition represents an event. (Gumzej et al.,

2006) have dealt with PEARL speciﬁcation which is

a hardware/software co-design methodology. They

offered a guide for system reconﬁgurations. (Nafti

et al., 2015) have presented a meta-model for re-

conﬁgurable embedded systems called Chameleon.

Chameleon is an object oriented meta-model allow-

ing reconﬁguration ﬂexibility and reduces the con-

sumption of both the processor time and the mem-

ory. (Krichen et al., 2011) and (Hamid and Krichen,

2010) have proposed a meta-model aiming at speci-

fying the distributed reconﬁgurable real-time embed-

ded systems. Also, they implemented an UML proﬁle

called RCA4RTES as an application of their meta-

model. (Dowling and Cahill, 2001) have proposed an

architecture meta-model enabling the creation of dy-

namic software architectures. They provided an adap-

tation contract description language aiming at sep-

arating the adaptive behavior of systems from their

functional behavior. (Lehmann et al., 2010) have pre-

sented a meta-modeling process for modeling self-

adaptive applications in order to facilitate the dynamic

adaptation at run-time.

All the previous researches have proposed several

modeling and speciﬁcation methods to describe re-

conﬁgurable systems. However managing the con-

text information is practically not studied. Providing

the models of context collection, classiﬁcation, pro-

cessing and dissemination is useful to minimize the

complexity of the reconﬁguration processes. More-

over, some of the existing models do not highlight

well how real-time constraints can be treated. Adding

to that, organizing the relation between the different

reconﬁgurations and resolving conﬂicting scenarios

are not mentioned as well. The functional constraints

like the inclusion or exclusion rules, the dependencies

relations, the sharing resources issues are not satis-

ﬁed with a clear and easy way. On these basis, we

propose a new meta-model overcoming all these con-

straints. We design a three levels meta-model where

each level concerns a particular directive. The ﬁrst

level tackles the relation of the system with its envi-

ronment. The second level is dedicated to manage the

system behavior by respecting all the possible con-

straints. The third level contains the set of the system

services. The next section presents a description of

the proposed meta-model.

3 NEW CONTEXT-AWARENESS

META-MODEL

In this section, we present the proposed concept by

showing a detailed description of the different com-

ponents of the meta-model.

3.1 Concept Description

Adaptive control systems have many common charac-

teristics. There are some execution steps repeated in

most of them regardless their ﬁeld of application and

their speciﬁcity of operation. For instance, the major-

ity of them have an agent or an entity responsible for

the digital control. This agent includes the controllers

and algorithms, the logic entities, etc. Also, they con-

tain another agent responsible for the mechanical part

(management of the sensors and actuators). And ﬁ-

nally, most of them include an entity responsible for

the interaction with the users (handling the I/O and

Context-awareness Meta-model for Reconﬁgurable Control Systems

227

the graphical display). In order to provide an easy

modeling of these entities and to express the relations

between them, a high level of abstraction is really

needed. In this context, we propose a new reconﬁg-

urable context-aware real-time meta-model. We de-

ﬁne this meta-model through giving three viewpoints:

(i) Structural approach, (ii) Behavioral approach, (iii)

Constraints perspective approach.

3.1.1 Structural Approach

The study of the adaptive systems allows us to deduct

that they can be designed through three levels archi-

tecture (see Fig. 1).

Figure 1: A generic structure of the context-aware real-time

systems.

The ﬁrst level can be called Context Acquisition.

It has to manage the communication with the events

triggered in the environment by means of sensors.The

context acquisition has to be achieved in two steps: (i)

Context collecting, (ii) Context classiﬁcation (it can

be reached by identifying the type of the event and by

attributing to it a set of properties). The second level

can be called Context Control and Reconﬁguration

Management. This level should contain the control

logic as well as the constraints veriﬁcation modules

which are basically the real-time and functional re-

strictions. The third level can be called System Ac-

tions and it has to include the system services. Hav-

ing a separation between the system services and the

control aspects helps developers to beneﬁt from the

re-usability and the ﬂexibility.

3.1.2 Behavioral Approach

The analysis of the behavior of adaptive control sys-

tems enables us to note many observations about their

control attitudes. Most of these systems need to per-

form an adaptation to the context they are putted in.

The adaptation logic has many shared steps, therefore

we propose a generic process expressed via the FSM

(Finite State Machine) of Fig. 2. Most of the self-

adaptive control systems have to detect to the even-

tual changes. Then, classifying the reconﬁguration

requests and identifying them is a necessary step that

helps to decide which control process to lead. After

that, checking the constraints that can be faced has to

be performed. Finally, sending the update commands

to the appropriate actuators is needed.

Figure 2: The FSM expressing a generic context adaptation.

3.1.3 Constraints Perspective Approach

A survey of the mostly faced constraints in adaptive

systems drives us to assume that they have a set of

shared constraints. Basically, all these systems have

to perform their tasks under real-time constraints.

Functional constraints also are always required. Thus,

we propose to use generic OCL rules (the Object Con-

straint Language which is a formal language for the

deﬁnition of constraints on UML models) with the

aim of abstracting the commonly faced constraints.

3.2 Meta-Model Deﬁnition

The meta-model is composed of three main packages

(see Fig. 3). RealTime ContextAware MetaModel is

the container package that contains: (i) Context Ac-

quisition, (ii) Context Control and Reconﬁguration

Management, and (iii) System Actions. These three

packages are linked through dependencies relations

(in particular import that allows to get the services

from another package and use which allows to utilize

the content of a package).

ENASE 2017 - 12th International Conference on Evaluation of Novel Approaches to Software Engineering

228

Figure 3: Model diagram of the proposed meta-model.

3.2.1 Context Acquisition

This package is composed of two packages: Context

Collecting and Context Classiﬁcation (see Fig. 4).

Context Collecting contains the meta-class Event Lis-

tening which is responsible for picking-up the trig-

gered events from the surrounding environment. For

this, it uses the meta-class Sensors Handling which

manages the different kind of the used sensors. Sen-

sors Handling is composed of the meta-class Sensor

that offers an abstraction of sensors (it has a set of

attributes like the name of the sensor, the detected

value...).

Figure 4: Context Acquisition Level.

Context Collecting package is accessed by the

package Context Classiﬁcation through to the meta-

class Get Reconﬁguration Event. Then, the reconﬁg-

uration events are imported by the meta-class Iden-

tifying Context in order to recognize their type. The

meta-class Characterizing Context will use the iden-

tiﬁed events and then it performs an abstraction. Fi-

nally, it will send them to the control unit through the

meta-class Communicate Context to Control Unit.

3.2.2 Context Control and Reconﬁguration

Management

This package uses the Context Acquisition in order to

get the reconﬁguration requests. It also imports the

services to be offered by the system from the pack-

age System Actions. It is composed of three packages

linked through dependencies relationships. The main

package is called Controlling Unit of Reconﬁguration

Processes (see Fig. 5). This package uses two other

packages which contain the system constraints. The

speciﬁcation of constraints is performed on the basis

of OCL. We distinguish between two types of con-

straints: functional and real-time.

Figure 5: Context Control and Reconﬁguration Manage-

ment Level.

Controlling Unit of Reconﬁguration Processes

contains ﬁve meta-classes. The meta-class Main Con-

trol includes the main control algorithm. It imports

the reconﬁguration requests through the meta-class

Get Context Reconﬁguration. To accomplish its task,

it uses the meta-class Get Functional Decision that

will interact with the package Functional Constraints

Control in order to pick-up the services to be executed

after having been checked by this package. Services

selection will be performed through the meta-class

Handle System Actions. The chosen services will be

sent to the meta-class Post Real-Time Tasks which is

responsible for the interaction with the package Real-

Time Constraints control.

The package Real-Time Constraints Control is re-

sponsible for scheduling the real-time tasks of the sys-

tems. It contains a meta-class called Communication

with Control Unit responsible for the interaction with

the package Controlling Unit of Reconﬁguration Pro-

Context-awareness Meta-model for Reconﬁgurable Control Systems

229

cesses. It contains also a meta-class called Real-Time

Scheduling including the main scheduling algorithm

which is responsible for keeping the feasibility of the

system. This is a generic meta-class that can be in-

stantiated to specify the type of scheduling. These

instances are called as follows: Periodic Scheduling,

Aperiodic Scheduling and Sharing Resources.

Functional Constraints Control is the third pack-

age. It contains a meta-class called Rules Checker.

This meta-class is responsible for checking the func-

tional rules of the smooth execution of the system

services. It uses a meta-class called Rules which is

composed of four other meta-classes specifying the

type of rules to be checked. These meta-classes are:

(i) Resources Allocation responsible for reserving the

needed resources for the system execution. (ii) Prece-

dence Rules responsible for organizing the tasks ac-

cording the precedence logic. (iii) Resources Sharing

responsible for indicating all the shared resources to

be used in the system. (iv) Coherence Rules indicat-

ing the system tasks that have to work simultaneously

and the tasks that have not to work together.

3.2.3 Systems Actions

This package is dedicated to be the container of the

systems services. It can contain N service pack-

ages. Every service meta-class can contain also M

task meta-classes. These meta-classes can be linked

through many types of relationship such as import,

use, access, etc. In Fig. 6 shows the abstraction of the

system service meta-classes.

Figure 6: The Package System Actions.

4 CASE STUDY

In order to evaluate the suitability of the proposed

meta-model, we present the modeling of a case study.

4.1 Case Study Presentation

The formal adaptive control system must adapt its be-

havior according to the dynamic changes of the en-

vironment (Landau et al., 1998). It is running under

real-time as well as functional constraints. It has a

set of services that contains the tasks to be performed.

Let us assume that this system uses a set of different

sensors (temperature, humidity, accelerometer, etc.).

Let the ten services called as follows: S

, i=1..10.

These services are distinct units containing the main

tasks of the different execution modes. A service is

executed after having been elected by the control unit.

This control unit organizes the services according to

the needs of the user: It can be executed in a periodic

way (ﬁxed by the developers) or in aperiodic way (re-

conﬁguration triggered by the events). Some of the

services are urgent and need to be treated before ex-

ceeding their deadlines.

Services are linked between each other through

various relationship types. Some of them are linked

by precedence relationship, which means that a ser-

vice S

cannot begin the execution before the end of

the service S

. The precedence order for this case

study is given by {(S1,6), (S2, 9), (S3, 5), (S4, 10),

(S5, 1), (S6, 7), (S7, 2), (S8, 3), (S9, 8), (S10, 4)} (i.e

S5 has to be executed at ﬁrst, then S7, then S8, etc.)

Other services have a resources constraint, which

means that they need some shared resources in their

execution. The shared resources of this case study are

{ X, Y, Z, R, Q,} and they are used as follows: {(S1,

X), (S2, R-Z), (S4, Y-Q), (S5, Y,R), (S7, X), (S10, R-

Z)}. Not only that, but also there are services having

a coherence relationship. It determines whether the

services can be executed together or not. In this sys-

tem, we assume that (S2 and S3), (S4 and S7) and (S8

and S5) are not coherent and the execution of the one

implies the blocking of the other. Finally, to be ex-

ecuted correctly, the system services need to allocate

some resources like the memory, energy, and proces-

sor time. Let us consider the resources amounts indi-

cated in the resources table. (see Table 1).

Table 1: Resources table.

Service 1 2 3 4 5 6 7 8 9 10

Memory 10 8 15 20 5 12 10 8 15 30

Energy 20 16 30 40 10 24 20 16 30 60

Processor 8 6 13 18 3 10 8 6 13 28

4.2 Case Study Modeling

The proposed formal adaptive system uses the con-

cepts proposed in the meta-model. A triggered event

in the environment is picked-up by the acquisition

level (see Fig. 7).

At this level, it is identiﬁed by attributing a type

and characterized by attributing a set of properties like

the Worst Case Execution Time (WCET), the prior-

ity, and the deadline. After being abstracted and pre-

sented by the ﬁrst level, the reconﬁguration request is

sent to the Context Control and Reconﬁguration Man-

ENASE 2017 - 12th International Conference on Evaluation of Novel Approaches to Software Engineering

230

Figure 7: The model of the case study.

agement level in order to be veriﬁed. The control unit

will guarantee the global control of the reconﬁgura-

tion process. In fact, the package Controlling Recon-

ﬁgurations will collaborate with the packages of the

veriﬁcation of the system constraints. It will interact

with both Real-Time Scheduling and Logic packages.

The Rate Monotonic (Lehoczky et al., 1989) is im-

plemented to handle periodic tasks, the Polling Server

(Davis et al., 1993) for the aperiodic tasks and the

Priority Ceiling Protocol (Sha et al., 1990) for the

scheduling under sharing resources. The system fea-

sibility is guaranteed when services do not exceed

their deadline. Also when the rate of utilization of the

processor is not at its maximum level. For this rea-

sons, we have developed a set of real-time constraints

by means of OCL (see Fig. 8). These queries have

to be always satisﬁed in order to keep system correct-

ness.

Figure 8: The feasibility OCL queries.

In the same manner, the package Logic is designed

to hold the functional constraints of the system. The

class Rules is composed of four other classes. Needed

Resources will manage the used resources during the

execution of the control application. It leads all al-

location and de-allocation processes. Common re-

sources manage the shared resources that can be used

by the system. Services Order is responsible for con-

trolling precedence constraints. Coherence mention

the services that are able to be treated together. The

OCL rules are implemented by the classes of the func-

tional constraints package in order to avoid confusion

(see Fig. 9).

Figure 9: The functional OCL rules.

4.3 Case Study Simulation

In this subsection, we present the simulation scenario

of the modeled adaptive system.

4.3.1 Implementation

We have developed a framework following the new

meta-model. This framework is holding the modules

existing in the three levels described by the meta-

model. We used C# programming language in the

implementation phase. Fig. 10 shows the class re-

sponsible for detecting events from the environment.

Figure 10: Listener class of the context collecting package.

4.3.2 Simulation

We consider the formal adaptive system presented in

the previous subsection. The services priorities are

Context-awareness Meta-model for Reconﬁgurable Control Systems

231

given as follows: {(S1, 5), (S2, 6), (S3, 3), (S4, 7),

(S5, 4), (S6, 5), (S7, 6), (S8, 6), (S9, 3), (S10, 1)

} . S10 has the highest priority, S4 the next highest

priority, and so on. The ﬁrst step performed by the

control unit is loading the services and checking the

functional constraints. Then, it starts the resources

allocation for each service (see Fig. 11)

Figure 11: The execution trace of the functional checking.

After that, the control unit interacts with the

scheduling package and set-up the scheduling table

in the real-time constraints module. Table 2 indicates

the capacity of each service as well as its period of

activation.

Table 2: Services capacities and periods.

Service 1 2 3 4 5 6 7 8 9 10

Capacity 5 6 3 2 7 4 5 6 3 1

Period 22 28 8 6 45 16 22 35 11 4

The Rate Monotonic scheduling protocol is se-

lected as the protocol to be used to handle periodic

services. The execution of the services is given in the

next Fig. 12. In each timer tick, the processor treats a

unit of a service.

Figure 12: The execution of the services according RMS

protocol.

The polling server has these properties: capac-

ity=4 and period=10. So, every 10 time units the

polling server will be activated in order to check the

list of aperiodic services (Fig. 13).

Figure 13: The activation of the Polling Server.

A reconﬁguration scenario take place when a re-

conﬁguration request is received by the control unit.

A reconﬁguration request can be a change in the en-

vironment, human intervention, components added or

deleted from the system, etc. These reconﬁgurations

are unpredictable and they are event driven.

We suppose that three reconﬁguration requests are

picked-up during the execution and that they have the

following properties (see Table 3).

Table 3: Reconﬁguration table.

id arrival wcet deadline priority target

R1 t=14 20 22 2 S3

R2 t=25 30 32 1 S10

R3 t=40 35 36 3 S7

Every reconﬁguration request is labeled by a

deadline, WCET, and priority and it aims at loading

a speciﬁc service. When they come in the system,

the control unit checks the priority of the current ex-

ecuting service and decides whether to interrupt the

execution or to re-schedule the ready tasks.

Figure 14: Checking the functional constraints of the recon-

ﬁguration request.

At t=14, a reconﬁguration event is coming to load

the service S3. This change is urgent and has a high

priority (priority=2). At this moment, the control unit

will check all the functional constraints and prepare

the new conﬁguration to be applied on the next ac-

tivation of the Polling Server. The services order is

necessarily updated, the service loaded by the recon-

ﬁguration request will take place in the schedule. Fig.

14 shows the execution trace of these updates. The

ENASE 2017 - 12th International Conference on Evaluation of Novel Approaches to Software Engineering

232

execution of the reconﬁguration service starts at the

activation period of the Polling Server (the moment

t=20) as shown in Fig. 15.

Figure 15: The execution of the loaded service.

The simulation is performed in this way: ev-

ery received request will induce a checking of the

functional constraints then the aimed service will be

scheduled according to the real-time protocols.

4.4 Comparison with other work

Comparing our proposed meta-model with other ex-

isting works will help us to highlight the originality as

well as the efﬁciency of our contribution. That is why

we compared our meta-model with the Chameleon

(Nafti et al., 2015). We chose to compare it with

Chameleon meta-model since it includes some sim-

ilarities. In fact, both meta-models intend to model

the reconﬁguration of control systems. Reconﬁgu-

rations are performed with the aim of satisfying the

adaptation of the system to its environment as well as

satisfying an optimal operation of the system.

In Chameleon, the classes composing the system

may change their behavior automatically. They con-

tain all the common methods for all the possible con-

ﬁgurations and a set of speciﬁc methods for each con-

ﬁguration. Therefore, if developers choose to imple-

ment the control applications of an adaptive control

system with Chameleon, they have to develop their

system services through the Chameleon classes. And

according to the deﬁnition of the Chameleon classes,

some components have to be created in all of them

such as: the method table, the scheduling table, the

data table, the constant table, etc.

Our meta-model shows a higher level of consis-

tency and robustness in fulﬁlling these goals. In fact,

it presents a separation between the system services

and the control processes. As seen before, all the con-

trol aspects are encapsulated into the Context Con-

trol and Reconﬁguration Management level while the

system services are encapsulated in the System Ac-

tions level. This distinction and separation of con-

cepts helps to beneﬁt from re-usability and make the

development process more ﬂexible. The most impor-

tant thing is that our architecture allows a better re-

source consumption since no redundancy or extra pro-

cessing is done.

As a proof, we present an approximate calcula-

tion of the response time of the system when using

our meta-model compared to using Chameleon meta-

model (see Fig. 16).

Figure 16: The system response time.

According to Figure 16, with the increasing num-

ber of the system services the system response time

taken by Chameleon is higher than the response time

taken by our meta-model. This can be explained by

the deﬁnition of several tables in each Chameleon

class. Surely these tables require much processing

time comparing to our meta-model. Thus, our meta-

model prove its robustness.

5 CONCLUSION

This paper proposed a new context-awareness meta-

model for developing real-time reconﬁgurable adap-

tive control systems. This new meta-model offers the

satisfaction of real-time as well as functional con-

straints that can be needed in adaptive control sys-

tems. Compared to other meta-models developed for

adaptive control systems, the reconﬁguration ﬂexibil-

ity, the awareness about the context of use and the

system response time are optimized. A framework

is implemented using C# programming language and

a formal case study is simulated as a running exam-

ple. To test the performance of the proposed meta-

model, we have performed measurement of the sys-

tem response time and we have compared the results

with Chameleon meta-model. We presented the anal-

ysis of the obtained results. In future works, we aim

to expand the ﬂexibility and robustness of the meta-

model by covering other control aspects such as the

quality of service issues and the compliance to multi-

platforms.

Context-awareness Meta-model for Reconﬁgurable Control Systems

233

REFERENCES

Al-Sultan, S., Al-Bayatti, A. H., and Zedan, H. (2013).

Context-aware driver behavior detection system in in-

telligent transportation systems. IEEE transactions on

vehicular technology, 62(9):4264–4275.

Calinescu, R., Grunske, L., Kwiatkowska, M., Mirandola,

R., and Tamburrelli, G. (2011). Dynamic qos manage-

ment and optimization in service-based systems. IEEE

Transactions on Software Engineering, 37(3):387–

409.

Capilla, R., Zimmermann, O., Zdun, U., Avgeriou, P.,

and K

uster, J. M. (2011). An enhanced architectural

knowledge metamodel linking architectural design de-

cisions to other artifacts in the software engineering

lifecycle. In European Conference on Software Archi-

tecture, pages 303–318. Springer.

Davis, R. I., Tindell, K. W., and Burns, A. (1993). Schedul-

ing slack time in ﬁxed priority pre-emptive systems. In

Real-Time Systems Symposium, 1993., Proceedings.,

pages 222–231. IEEE.

Dowling, J. and Cahill, V. (2001). The k-component ar-

chitecture meta-model for self-adaptive software. In

International Conference on Metalevel Architectures

and Reﬂection, pages 81–88. Springer.

Feiler, P. H., Lewis, B. A., and Vestal, S. (2006). The

sae architecture analysis & design language (aadl) a

standard for engineering performance critical systems.

In 2006 IEEE Conference on Computer Aided Con-

trol System Design, 2006 IEEE International Con-

ference on Control Applications, 2006 IEEE Interna-

tional Symposium on Intelligent Control, pages 1206–

1211. IEEE.

Gumzej, R., Colnaric, M., and Halang, W. A. (2006).

Safe and timely scenario switching in uml real-time

projects. In Ninth IEEE International Symposium

on Object and Component-Oriented Real-Time Dis-

tributed Computing (ISORC’06), pages 8–pp. IEEE.

Hamid, B. and Krichen, F. (2010). Model-based engi-

neering for dynamic reconﬁguration in drtes. In Pro-

ceedings of the Fourth European Conference on Soft-

ware Architecture: Companion Volume, pages 269–

276. ACM.

Idriss, R., Loukil, A., and Khalgui, M. (2015). New mid-

dleware for secured reconﬁgurable real-time systems.

In International Conference on Intelligent Software

Methodologies, Tools, and Techniques, pages 469–

483. Springer.

Krichen, F., Hamid, B., Zalila, B., and Jmaiel, M. (2011).

Towards a model-based approach for reconﬁgurable

dre systems. In European Conference on Software Ar-

chitecture, pages 295–302. Springer.

Landau, I. D., Lozano, R., M’Saad, M., and Karimi, A.

(1998). Adaptive control, volume 51. Springer Berlin.

Lehmann, G., Blumendorf, M., Trollmann, F., and Al-

bayrak, S. (2010). Meta-modeling runtime models. In

International Conference on Model Driven Engineer-

ing Languages and Systems, pages 209–223. Springer.

Lehoczky, J., Sha, L., and Ding, Y. (1989). The rate mono-

tonic scheduling algorithm: Exact characterization

and average case behavior. In Real Time Systems Sym-

posium, 1989., Proceedings., pages 166–171. IEEE.

Lepuschitz, W., Zoitl, A., Vall

ee, M., and Merdan, M.

(2011). Toward self-reconﬁguration of manufacturing

systems using automation agents. IEEE Transactions

on Systems, Man, and Cybernetics, Part C (Applica-

tions and Reviews), 41(1):52–69.

Lo, C.-C., Chen, C.-H., Cheng, D.-Y., and Kung, H.-Y.

(2011). Ubiquitous healthcare service system with

context-awareness capability: Design and implemen-

tation. Expert Systems with Applications, 38(4):4416–

4436.

Nafti, A., Romdhani, M., and Khalgui, M. (2015).

Chameleon: New object oriented solution for adaptive

control systems. In Pervasive and Embedded Comput-

ing and Communication Systems (PECCS), 2015 In-

ternational Conference on, pages 1–8. SCITEPRESS.

Schilit, B. N. and Theimer, M. M. (1994). Disseminating

active map information to mobile hosts. IEEE net-

work, 8(5):22–32.

Schuller, B., Dunwell, I., Weninger, F., and Paletta,

L. (2013). Pervasive serious gaming for behavior

change–the state of play. IEEE pervasive computing,

3(12):48–55.

Sha, L., Rajkumar, R., and Lehoczky, J. P. (1990). Prior-

ity inheritance protocols: An approach to real-time

synchronization. IEEE Transactions on computers,

39(9):1175–1185.

Siddiqi, A. and de Weck, O. L. (2008). Modeling meth-

ods and conceptual design principles for reconﬁg-

urable systems. Journal of Mechanical Design,

130(10):101102.

Sukode, S., Gite, S., and Agrawal, H. (2015). Context aware

framework in iot: A survey. International Journal,

4(1).

Valentini, A., Gharbi, A., Khalgui, M., and Gharsellaoui, H.

(2013). Safety reconﬁguration of embedded control

systems. Embedded Computing Systems: Applica-

tions, Optimization, and Advanced Design: Applica-

tions, Optimization, and Advanced Design, page 184.

Zhan, K., Faux, S., and Ramos, F. (2014). Multi-scale con-

ditional random ﬁelds for ﬁrst-person activity recog-

nition. In Pervasive Computing and Communications

(PerCom), 2014 IEEE International Conference on,

pages 51–59. IEEE.

Zhang, D., Huang, H., Lai, C.-F., Liang, X., Zou, Q., and

Guo, M. (2013). Survey on context-awareness in

ubiquitous media. Multimedia tools and applications,

67(1):179–211.

ENASE 2017 - 12th International Conference on Evaluation of Novel Approaches to Software Engineering

234