This paper proposes an active fault diagnosis method to enforce the diagnosability of discrete event systems using labeled Petri nets by constructing a diagnostic supervisor. For a non-diagnosable net model, its diagnosability is viewed as a control specification and addressed by using supervisory control techniques. First, an event-based monitor and a Petri net structure, referred to as data isolation arcs, are introduced to apply control specifications for labeled Petri nets. Then, a diagnostic supervisor reachability graph is generated to estimate the current state of the diagnoser. By analyzing the diagnostic supervisor reachability graph, an integer linear programming model is formulated to design a diagnostic supervisor, which can prevent the system from entering into any indeterminate cycle only by observing the occurrence of events. Finally, by the obtained diagnostic supervisor, the resulting net model is shown to be diagnosable. Some examples are presented to demonstrate the proposed method. Note to Practitioners—Faults have a significant impact on the normal operation of a system, and timely detection and isolation are crucial to ensuring system stability and production efficiency. Nevertheless, in certain systems, the occurrence of faults cannot be determined by a finite number of observations. To address this problem, this work introduces an active fault diagnosis method in the framework of labeled Petri nets, aiming to enforce the diagnosability of a system. The diagnosability condition is treated as a control specification such that it is readily accessible for practitioners to construct a diagnostic supervisor with Petri nets by following a typical and traditional control paradigm, which ensures that the controlled system is diagnosable.

Generalized stochastic Petri nets (GSPNs) have been extended to several dynamic-structure formalisms providing suitable tools for the modeling and verification of reconfigurable discrete-event systems (R-DESs). However, analyzing the performance of large-complex R-DESs remains a big challenging issue. Indeed, dynamic-structure GSPNs still rely on old-fashioned techniques often causing the state-space explosion problem. In this article, we present a new technique for the quantitative analysis of a dynamic-structure formalism called reconfigurable GSPNs without computing the whole state space. This work describes new reconfiguration forms used to preserve desired quantitative properties of parts of interest after each reconfiguration. Therefore, it is only required to verify the examined properties at an initial configuration. The proposed technique is proven to effectively reduce the state space and shorten the computation time in such cases. Finally, some experimental results are provided to illustrate that, from a computational perspective, the developed approach outperforms the existing tools.

This article deals with reconfigurable uniprocessor systems powered by a renewable energy source under real-time and resource sharing constraints. A reconfigurable system is defined as a set of implementations, each of which is encoded by real-time periodic software tasks. Reconfiguration is a flexible runtime scenario that adapts the current system’s implementation to any related environment evolution under well-defined conditions. A task is characterized by an effective calculated deadline that should be less than a maximum deadline defined in user requirements. The main problem is how to calculate the effective deadlines of the different periodic tasks in the different implementations under possibly the predicted renewable energy source and the sharing of resource constraints. We propose an offline method based on three solutions to calculate the deadlines of tasks. The first serves to compute the deadlines ensuring the real-time system feasibility and also minimizes the number of context switches by assigning the highest priority to the task with the smallest maximum deadline. The second computes the deadlines ensuring the respect of energy constraints, and the third computes the deadlines ensuring the respect of resource sharing constraints. These three solutions calculate the possible deadlines of each task in the hyperperiod of the corresponding implementations. We develop a new simulator called DEAD-CALC, that integrates a new tool called RANDOM-TASK for applying and evaluating the proposed solutions. The conducted experimentation proves that this methodology provides deadlines with affecting neither the load nor the processor speed while reducing the calculation time.Note to Practitioners—Real-time software is particularly difficult to design since, in addition to ever more complex functional constraints, it has to satisfy a set of stringent nonfunctional requirements, such as deadlines. In fact, the violation of deadlines can lead to breakdowns, data loss, and so on, which can be catastrophic for critical applications. This article presents the DEAD-CALC project for computing efficiently the deadlines of reconfigurable real-time devices to run possibly under energy and resource sharing constraints in all the system implementations. A device, in the software level, is a superset of implementations, each of which (i.e., a set of periodic software tasks) is activated and executed at a particular time according to user requirements. DEAD-CALC reduces the development time by computing the deadlines to be certainly respected without any additional feasibility analysis of the device. The calculation can only consider the real-time aspects, or both the harvesting energy and resource sharing constraints, giving the user the ability to configure the system under different conditions. DEAD-CALC is a visual environment that can be simply used by designers to compute and display these deadlines, with a few clicks, in arranged tables, and in a short time. This project can be a future reference for industrial partners who will be focusing on various real-time applications design, such as the intelligent manufacturing industry, intelligent transportation systems, embedded systems, wireless sensor networks, smart grids, medical control devices, and military platforms.

This article deals with improved formal verification of reconfigurable discrete-event systems (DESs) modeled by reconfigurable timed net condition event systems (R-TNCESs). An R-TNCES consists of a set of timed net condition event systems, each of which represents a particular behavior of a DES, and a reconfiguration scenario is a switching mode from a timed net condition event system to another. However, the verification with the classical computation tree logic (CTL) as well as the related extensions increases the number of properties for complete verification of a complex R-TNCES. We propose reconfigurable CTL as a new extension of CTL to reduce such a number. New connectors of reconfigurable CTL are proposed, with their formal syntax and semantics, and a set of new algorithms is proposed to control the complexity of model checking. We use a benchmark production system for the performance evaluation of the proposed approach. Reduction in the number of properties to be checked is shown, and consequently, the related validation time is reduced.Note to Practitioners—This research represents a new orientation for guiding efficiently the model checking of reconfigurable discrete-event systems. A classification of properties described in computation tree logic (CTL), according to their dominance and equivalence relations, allows one to conduct an efficient verification by avoiding inefficient calculation due to redundant properties. In this case, giving a verification order for these properties allows one to shorten their verification time. An extension named reconfigurable CTL describes the new syntax of the proposed classification. This approach can be applied in modeling and verification of advanced reconfigurable systems arising from smart grids, adaptive sensor networks, intelligent transportation, reconfigurable manufacturing, and embedded systems.

This paper deals with the medium between two reconfigurable sensor nodes characterized by radio interfaces that support multiple channels for exchanging real-time messages under energy constraints. These constraints are violated if the consumed energy in transmission is higher than the remaining quantity of energy. A reconfiguration, i.e., any addition or removal of tasks in devices and consequently of messages on the medium, can cause the violation of real-time or energy constraints at run time. To achieve a feasible scheduling in time (i.e., message deadlines will be respected) and energy (i.e., there is available energy) on the medium, we propose new dynamic solutions: Balance, Dilute, and a Combination of them to manage any addition or removal of messages. The proposed approach utilizes the energy harvesting techniques and the PowerControl algorithm to reduce the nonharvested consumed energy. The proposed strategies achieve significant improvement over existing methods and provide the highest percentage of adding messages, with a lower average in response time and energy consumption. They reach a percentage of success in adding the highest priority messages while meeting deadlines up to 85%.

This paper deals with real-time scheduling of homogeneous multicore platforms powered by a battery to be periodically recharged. A system is composed of reconfigurable real-time dependent and periodic tasks to be assigned to different cores interconnected by a network-on-chip (NoC). The system is subject to reconfigurations, which are automatic operations allowing the addition and/or removal of tasks as well as their exchanged messages on the NoC. Consequently, any reconfiguration can violate real-time and energy constraints on cores as well as the NoC when the energy is unavailable until the next recharge. A novel periodic task model based on elastic coefficients and a new scheduling strategy are proposed to compute useful temporal parameters allowing for tasks and messages to meet the related constraints while controlling the communication cost on the NoC. This strategy is compared with an integer linear programming-based optimal solution, and a tool named OptimalMappingTasks is developed to run different simulations that prove the originality of this paper's contribution.

Wireless sensor networks (WSNs) can be seriously impacted by several changes in behavior. As a measure of optimality, a network should react in real-time. However, even if some reactions can make the system flexible, they can cause significant damages when they are not well-structured. Moreover, the scenarios of reconfigurations can affect several parameters within a wireless sensor network. Among these parameters it is possible to name the energy efficiency, the memory limitation within a node, the real-time constraints at the level of the nodes and the network in general. Either through the application or the transmission of the reconfiguration scenarios, some parameters are severely altered. A metamorphosis of the internal architecture of the nodes is proposed in this research work as well as a policy of communication between several nodes aiming to adapt the network to any change. The resulting proposition offers general efficiency in energy and real-time constraints. The efficiency is realized by the application of a pipelined approach, dealing with the incoming reconfiguration scenarios, and a communication protocol, based on a priority energy and deadline aware scheduling algorithm (a multicriteria scheduling algorithm). This protocol is capable of optimizing the transmission of both reconfiguration scenarios and sensed data simultaneously. The solution is tested on a network connecting several cars during an automobile journey and the results validate the efficiency of this proposition.

This paper deals with software validation of flexible discrete-event systems. A reconfiguration scenario is any run-time adaptation of the software execution according to user requirements. Nevertheless, since several behaviors can be redundant from an execution to another, using the object constraint language (OCL) is not useful to specify all constraints that should be satisfied by a system. We propose an extension of OCL named reconfigurable OCL for improving the specification and validation of constraints related to different execution scenarios of a system. An ROCL metamodel is proposed with formal syntax and semantics. This solution gains in terms of validation time and quick expressions of constraints. We apply the proposed extended language to reconfigurable wireless sensor networks to highlight the benefits of this contribution.

This paper deals with the formal verification of reconfigurable discrete event control systems (RDECSs) using reconfigurable timed net condition/event systems (R-TNCESs) formalism. A reconfigurable system switches from a mode to another during its working process to adapt its behavior to the related environment. By including such a feature, RDECSs become complex and their verification is often expensive in terms of computation time and memory. In this paper, a new methodology for formal verification of RDECSs is proposed in order to ensure the correctness of these systems with a reduced cost (decreasing the verification time and memory occupation). The proposed contribution includes an improved modeling and verification of RDECSs. The modeling with R-TNCESs is enriched with all reconfiguration forms, and the verification involves an improvement method that avoids any redundancy and cancels unnecessary calculations. In addition, a visual tool called Rec-AG based on the proposed methodology is developed. The performance evaluation of this paper is achieved by measuring computation time and memory for several systems and different sizes of the problem. This paper's contribution is applied to the benchmark production system FESTO.

State space techniques are one of the main approaches deployed for the analysis of concurrent systems. However, state space construction is stalled by a common phenomenon called the state explosion problem which makes it a tough task or even impossible when the state space computation demands prohibitive cost (time and memory). We limit general resource allocation systems (RASs) to a certain class whose state space can be hierarchically constructed, yet it comprises various enough types of real-world discrete event systems, such as automated manufacturing systems. This paper focuses on a class of RASs modeled with Petri nets (PNs), where, through pure algebraic operations, a novel method to compute the state spaces is proposed, which is motivated by the superposition property. Given a PN model of a system and a target resource configuration, we first propose a special initial marking called the initial basis marking and compute the corresponding reachability graph. Then, we increase the capacity of the resource places in an incremental way and generate the reachability graphs by taking advantage of the PN structure and the previously computed reachability graph until the capacity function of resources reaches the target resource configuration. A complete enumeration of reachable states can be obtained by a recursive scheme. Experimental studies also demonstrate the efficiency of the proposed approach in terms of computational cost and its high-potential to cope with the state-explosion problem.

Low power and lossy networks (LLNs) require a routing protocol under real-time and energy constraints, congestion aware and packet priority. Thus, Routing Protocol for Low power and lossy network (RPL) is recommended by Internet Engineering Task force (IETF) for LLN applications. In RPL, nodes select their optimal paths towards their preferred parents after meeting routing metrics that are injected in the objective function (OF). However, RPL did not impose any routing metric and left it open for implementation. In this paper, we propose a new RPL objective function which is based on the quality of service (QoS) and congestion-aware. In the case paths fail, we define new RPL control messages for enriching the network by adding more routing nodes. Extensive simulations show that QCOF achieves significant improvement in comparison with the existing objective functions, and appropriately satisfies real-time applications under QoS and network congestion.

This paper deals with reconfigurable discrete event control systems (RDECSs). We model RDECSs using reconfigurable timed net condition/event systems (R-TNCESs) formalism which is an extension from Petri nets to deal with reconfiguration properties. Model-based diagnosis algorithms are widely used in academia and industry to detect faulty components and ensure systems safety. The application of these methods on reconfigurable systems is impossible due to their special behavior. In this paper, we propose accomplishing techniques of backward reachability to make reconfigurable systems model-based diagnosis possible using R-TNCESs. The flexibility among reconfigurable systems like RDECSs allows them to challenge recent requirements of markets. However, such properties and complicated behavior make their verification task being complex and sometimes impossible. We deal with the previous problem by proposing a new methodology based on backward reachability of RDECSs using (R-TNCESs) formalism including improvement methods. The proposed methodology serves to reduce as much as possible redundant computations and gives a package to be used in model-based diagnosis algorithms. The paper’s contribution is applied to a benchmark modular production system. Finally, a performance evaluation is achieved for different sizes of the problem to study benefits and limits of the proposed methodology among large-scale systems.

The MAVLink is a lightweight communication protocol between Unmanned Aerial Vehicles (UAVs) and ground control stations (GCSs). It defines a set of bi-directional messages exchanged between a UAV (aka drone) and a ground station. The messages carry out information about the UAV's states and control commands sent from the ground station. However, the MAVLink protocol is not secure and has several vulnerabilities to different attacks that result in critical threats and safety concerns. Very few studies provided solutions to this problem. In this paper, we discuss the security vulnerabilities of the MAVLink protocol and propose MAVSec, a security-integrated mechanism for MAVLink that leverages the use of encryption algorithms to ensure the protection of exchanged MAVLink messages between UAVs and GCSs. To validate MAVSec, we implemented it in Ardupilot and evaluated the performance of different encryption algorithms (i.e. AES-CBC, AES-CTR, RC4 and ChaCha20) in terms of memory usage and CPU consumption. The experimental results show that ChaCha20 has a better performance and is more efficient than other encryption algorithms. Integrating ChaCha20 into MAVLink can guarantee its messages confidentiality, without affecting its performance, while occupying less memory and CPU consumption, thus, preserving memory and saving the battery for the resource-constrained drone.

This paper deals with formal modeling and verification of reconfigurable hierarchical discrete-event control systems (RDECSs). The system's behavior is with a dynamic structure for being adapted to related environment. We propose an extension of timed automata named reconfigurable hierarchical timed automata (RHTA) to consider hierarchy and reconfigurability of the considered system. Since the verification becomes an expensive task in terms of computation time and memory, an improved verification methodology is proposed for RHTA where redundancies and similarities between system's configurations are considered which controls verification cost. The proposed contribution is applied to an example to evaluate the related performance where gains in term of verification time are marked.

To guarantee a better power availability in complex power systems, this paper provides a new strategy that deals with smart grids rebuilding for faults recovery. We propose a heuristic that schedules technical teams interventions and allows to carry favour clients with no recovery sources compared with those that are covered by renewable sources, and the ones recovered by pertinent emergency lines. Thus, we overcome this complexity by providing an oriented cloud architecture based on effective computing sources for assisting technical teams in recovery, it permits to obtain gains in term of total energy availability and to reduce loss time. We implement a simulation tool for smart grid rebuilding based on a cloud system called SGCS-RB which is experimented on different smart grids, and we evaluate the number of recovered failures which is improved thanks to the proposed contribution.

IEC 61499 provides a standardized approach for the development of distributed control systems. The standard introduces a component architecture, based on function blocks that are event-triggered components processing data and signals. However, it gives only limited support for the design of reconfigurable architectures. In particular, handling of several reconfiguration scenarios is quite heavy on this level since a scenario changes the execution model of the system due to requirements. To this end, a new IEC 61499-based model named reconfigurable function blocks (RFBs) is proposed. An RFB processes the reconfiguration events and switches directly to the suitable configuration using a hierarchical state machine model. The latter represents the reconfiguration model which reacts on changes in the environment in order to find an adequate reconfiguration scenario to be executed. Each scenario presents a particular sequence of algorithms, encapsulated in another execution control chart slave which represents the control model of an RFB. This hierarchy simplifies the design and separates the reconfiguration logic from control models. To verify its correctness and alleviate its state space explosion problem in model checking, this paper translates an RFB system automatically into a generalized model of reconfigurable timed net condition/event systems (GR-TNCES), a Petri net class that preserves the semantics of an RFB system. In this paper, along with verification of deterministic properties, we also propose to quantify and analyze some probabilistic properties. As a case study, we consider a smart-grid system, interpreting permanent faults in it as reconfiguration events, and we characterize them with the expected occurrence probability and the corresponding repair time. A tool chain ZiZo is developed to support the proposed approach.

This paper deals with the reconfigurable real-time systems that should be adapted to their environment under real-time constraints. The reconfiguration allows moving from one implementation to another by adding/removing/modifying parameters of real-time software tasks which should meet related deadlines. Implementing those systems as threads generates a complex system code due to the large number of threads, which may lead to a reconfiguration time overhead as well as the energy consumption and the memory allocation increase. Thus this paper proposes a multiobjective optimization approach for reconfigurable systems called MO2R2S for the development of a reconfigurable real-time system. Given a specification, the proposed approach aims to produce an optimal design while ensuring the system feasibility. We focus on three optimization criteria: 1) response time; 2) memory allocation; and 3) energy consumption. To address the portability issue, the optimal design is then transformed to an abstract code that may in turn be transformed to a concrete code which is specific to a procedural programming (i.e., POSIX) or an object-oriented language (i.e., RT-Java). The MO2R2S approach allows reducing the number of threads by minimizing the redundancy between the implementation sets. By an experimental study, such optimization permits to decrease the memory allocation by 28.89%, the energy consumption by 40.2%, and the response time by 61.32%.

International audience

This paper revolves around a test of a reconfigurable hardware system based on sequential logic (abbreviated, RHSS). The latter is a sequential hardware device that allows to change the hardware resources at run-time in order to modify the system functions and therefore to dynamically adapt the system to its environment. In order to reduce time and effort for finding test patterns and analyzing a circuit for its faults, we endeavor to show the way inter-circuits fault collapsing for RHS based on combinational logic remains valid and can be extended to RHSS. The application of the inter-circuits technique reduces the number of faults dealt with by eliminating redundant faults existing between circuits composing the RHSS. For a scalable RHSS, it is often impractical to reach an overall fault coverage. We propose two test techniques that target a minimal necessary set of faults while ensuring an acceptable fault coverage that answers the manufacturer requirements. For so doing, we promote a guiding method for rating potential faults in terms of their occurrence and severity where a fault is weighted according to how serious its consequence and how frequent it can occur. The proposed approach is implemented in a new version of the original TnTest tool.

This paper deals with the test of a reconfigurable hardware system (RHS). The latter is a hardware device that allows to change the hardware resources at runtime in order to modify the system functions and therefore to dynamically adapt the system to its environment. The increasing functional complexity of embedded systems and the transition to the RHS make the hardware testing a challenging task, especially under the confine of providing a high quality with a low cost. Considering the fact that the hardware test represents a key cost factor in a production process, an optimal test strategy can be advantageous in the competitive industrial market. Accordingly, this paper introduces a new methodology for an efficient hardware test of RHS. For an RHS, the number of stuck-at faults can be very large, which leads to a significant slowdown in the testing process. Because of the redundancy of faults between the different circuits composing an RHS, the proposed methodology aims at minimizing the number of faults using the inter-circuits relationships and consequently at providing an optimal fault set that can be effectively used for testing. Efficient techniques for test generation and test set validation are proposed to provide the test patterns for faults reduced by inter-circuits fault collapsing. The application of the generated test patterns is typically sufficient to provide an overall fault coverage. The proposed methodology is implemented in a new visual environment named TnTest. An experimental study confirms and validates the expected findings. Note to Practitioners-This paper addresses possible challenges for future generations of adaptive embedded systems. It proposes an original methodology for an efficient reconfigurable hardware system (RHS) hardware test. The main objective is to significantly reduce time and cost needed for the testing process. For an RHS, the number of stuck-at faults can be very large, which can cause a major slowdown in the hardware test. Based on the inter-circuits relations existing between the different circuits composing an RHS, the proposed methodology decreases considerably not only the number of the faults but also the test patterns needed for testing. The application of the generated test patterns is typically sufficient to provide an overall fault coverage. The proposed methodology is implemented in a new visual software environment named TnTest, which is capable of providing the smallest fault set as well as the efficient test set that can be effectively used for testing. This environment can be applied to test any embedded device that can be deployed in any new application based on flexible technologies. It can also be useful in manufacturing industries for a required improvement of the production process in relation to time and cost.

The pipeline of reconfiguration is a novel approach that gives a decision making mechanism for any system of tasks when several reconfiguration scenarios are required. These scenarios represent the run-time operations that allow automatic functional modification of the system behavior. In the case of their frequent income, the pipeline follows a specific set of steps in order to figure out the scenarios that need to be applied without altering its own performance. The steps are represented by a sequence of modules. The first module checks the availability of the resources needed by the tasks. The second maintains the stability by rejecting any insupportable flow of software reconfigurations that can destabilize a system. The third module checks the availability of memory for each software reconfiguration request, whereas the fourth verifies the availability of energy for the execution of a new system software configuration. The last module checks the schedulability of this configuration by changing the priorities of the finally accepted tasks in order to reduce their response and blocking times, and to meet their deadlines. The feasibility of the reconfiguration through this approach allows its implementation in wireless sensor nodes. Known by their important requirements in terms of memory and energy, this proposition is adequate when it comes to guaranteeing a maximum lifespan of the nodes. Therefore, the pipeline of reconfiguration is integrated as a middleware within the software architecture of a node. The functionality of this middleware is coordinated by the mean of a set of threads that manage the communication between the pipeline of reconfiguration and the operating system. A tool has been developed within LISI Laboratory to encode this proposition and show its impact on a large range of real devices under diversified scenarios of reconfigurations.

This paper deals with reconfigurable wireless sensor networks (RWSNs) that should be adapted to their environment in order to minimize the energy consumption during the communication among nodes and consequently to maximize the lifetime of the network as much as possible. An RWSN is assumed to be composed of a set of nodes located in distributed zones such that each node executes reconfigurable software tasks to control local sensors. We propose in a previous work a zone-based multiagent architecture for an RWSN where a communication protocol is well-defined to optimize distributed reconfigurations. This architecture combines all possible reconfiguration forms of the network to be adapted to its environment under energy constraints. With the multiagent architecture we gain in term of energy to be consumed by each node in the network. After applying a set of reconfiguration scenarios, the total charge of the network decreases. In order to preserve this charge as much as possible before the next recharging operation, in this particular study, we tend to resize geographically the zones in an RWSN. We propose also to move the mobile nodes in order to increase the network lifetime. A new run-time power oriented methodology is reported, which manages the zones and their mobile nodes in order to control the energy consumption. Two dynamic solutions are applied: 1) the resizing of zones and 2) the mobility of nodes. For the new proposed methodology, we present a set of equation systems to model the resizing of zones and the mobility of nodes. The solution of these systems allows us to conclude that we can conserve more energy during the communication among network elements (nodes, stations, and agents). The contributions are applied to a case study that we simulate with the reconfigurable wireless network environment1to analyze the research originality.

As with the requirements of high-performance and flexible computing, reconfigurable computing systems have become a subject of a great deal of research. Reconfigurable computing systems have to deal with unpredictable events from the environment such as arrival of new tasks, and hardware or software failures, by adapting the task allocation and scheduling, in order to maintain the system feasibility and performance. This paper presents a novel adaptive approach to address the real-time task scheduling issue in reconfigurable multiprocessor embedded systems based on energy harvesting with the consideration of system performance optimization. An energy efficient offline task mapping and scheduling algorithm is proposed to balance the workload in the multiprocessor embedded system. In order to optimize the system performance and to guarantee the system correctness in the presence of reconfiguration scenarios, a distributed control system is built to process a task migration. A cost function to evaluate the energy and time overheads of tasks migration is proposed. Extensive performance evaluations show the effectiveness of the proposed approach in terms of deadline miss ratio, and the energy gain compared with the related state-of-the-art techniques.

This paper presents new challenges for the development of reconfigurable wireless sensor networks (RWSNs) that adapt dynamically their behaviors to their environment under different properties. An RWSN is a set of networked nodes that execute reconfigurable software tasks for the control of local sensors. We propose a new design methodology named RWiN of an RWSN using unified modeling language (UML) to analyze, construct, develop, and verify easily RWSN architectures. For that, we formulate a metamodel of RWSN based on UML to describe a zone-based architecture that uses a communication protocol for the optimization of distributed reconfigurations. To control the design complexity, we model each agent of this architecture by nested state machines. To verify the temporal constraints by communicating agents, each one is modeled by a timed automaton. The paper's contribution is applied to a case study, which is simulated with TRMSim-WSN and UPPAAL environment to expose the originality of this new architecture.

Failure propagation in smart grids (SGs) complicates and prolongs the recovery time as the faults to be resolved increase. This paper presents the design and implementation of a framework for SGs modeling, simulation, and recovery. The proposed approach is based on a multiagent system composed of static and mobile agents to ensure local and remote resolutions. The efficiency and completeness of the power system recovery protocol are proved as all the existing solutions are analyzed. The use of fault classification and a performing communication process as well as the deployment of local distributed databases updated at run-time ensure the effectiveness of the proposed fault recovery strategy. An experimental study confirms and validates the expected results.

Current industrial systems need to interact with the surrounding environment in order to provide more efficiency. In such systems, used software applications must be strong enough to answer run-time needs. Context-aware applications seem to be an appropriate solution that can satisfy adaptation to the continuous changes. Safe reconfigurations require the respect of tasks deadlines and the avoidance of blocking. However, existing solutions are still insufficient and lack many important services. In this paper, we propose a new context-aware framework for developing control applications in dynamically changing environment. We focus on respecting real-time as well as functional constraints. The proposed framework structure provides simple reconfiguration handling and boosts the awareness of applications. This paper describes the definition of the proposed framework and its design. To prove the validation of the new approach, we have performed a case study and simulations.

This paper presents an extension to the IEC 61499 standard called Reconfigurable Function Block. The major goal is to optimize the design of a network of Function Blocks by encapsulating several reconfiguration scenarios in one function block. We define the events triggering the reconfiguration and we attach a probability to each event to express its uncertainty. In order to verify the system and to evaluate its performances, we model it with a class of Petri nets. The proposed approach is applied to a medical platform BROS as a case study throughout a developed software tool called ZiZo v3.

This paper explores the energy-aware strategy for adaptive task allocation of sporadic task model in distributed reconfigurable embedded systems powered by a renewable energy source. It is challenging to ensure hard real-time deadlines of sporadic tasks in distributed reconfigurable embedded systems that entirely rely on energy harvesting with limited capacity storage because their release times and periods are unknown beforehand. In this regard, we propose a new scheduling algorithm for sporadic task model in energy harvesting reconfigurable distributed embedded system. The proposed approach generates an energy efficient offline task assignment heuristic. Then, the offline stage is dynamically extended online by applying a dynamic adaption algorithm. The latter performs three solutions: (i) Migration, (ii) Degradation of the execution mode, and (iii) Removal of tasks in order to maintain schedulability and sustainability of the application software. Simulations show the efficiency of the proposed approach in term of deadline success ratio.

The reconfigurable NoCs are designed to deal with the intensive frequency of the exchanged messages rate at run-time. The overload scenarios are then frequent and the Quality of Service (QoS) is not satisfied. To fulfill a higher level of adaptiveness at run-time, we expose the problem of the run-time NoC reconfiguration under QoS constraints. The contributions of this paper are twofold. First, we present a run-time reconfiguration in NoC based on reconfiguring the faulty network devices. It can dynamically add or remove one or a set of messages so that critical messages can be routed correctly. We introduce a priority level of messages to ensure the delivery of the most important ones to satisfy (m, k) based QoS constraints. Secondly, through a case study, we present a formal approach based on Reconfigurable Timed Net Condition/Event Systems (R-TNCES) to verify temporal logic properties with the model Checker SESA. Using this approach in any given configuration of the NoC, we can deduce if the QoS will be guaranteed or not.

In this paper, we are interested in real-time scheduling of a distributed reconfigurable embedded system powered by a renewable energy source. Uncertainty of energy availability in energy harvesting systems makes the problem of task scheduling more challenging. A reconfiguration scenario is defined as an operation that allows the addition-removalmodification of tasks which may result in timing infeasibility. The system updates its behaviour in accordance with user requirements in reaction to unpredictable events from the environment. The contribution of this paper concerns energyaware strategies for adaptive task allocation. The proposed approach is decomposed into two phases a) Static task assignment heuristic, and b) Dynamic adjustment algorithm. In order to maintain schedulability and sustainability of the application software, the dynamic adjustment algorithm performs three functions: i) Migration, ii) Degradation of the execution mode, and iii) Removal of tasks. We employ a novel energy prediction algorithm. A simulation study brings to light the effectiveness of the proposed approach in terms of deadline success ratio.

International audience

This research paper deals with the modeling and code generation of Reconfigurable Control Systems (RCS) following UML and B methods. Reconfiguration means dynamic changes of the system behavior at run-time according to well-defined conditions to adapt it to its environment. A reconfiguration scenario is applied as a response to user requirements or any possible evolution in its environment. We affect a Reconfiguration Agent (RA) to RCS to apply an automatic reconfiguration. A new approach called (R-UML-B) is proposed. It consists of three complementary phases: UML specification, B specification and the simulation phase. The first phase models the RCS following UML class and state diagrams. The second phase translates UML specification into B specification according to the well-defined rules and R-UML-B formalism to define the Behavior, Control, Listener, Database and Executive modules of the RCS. Then, we determine the refinement model and the code generation of the B abstract model in C code. We verify the RCS by following the B method in order to guarantee the consistency and the correctness of the specification, refinement and code generation levels. The third phase imports the generated C code to implement a simulator, named B Simulator in order to test and validate the proposed approach. All the contributions of this work are applied to the benchmark production system EnAS.

This paper introduces a method for modeling and simulation of a production system with different energy modes. We aim to save the energy in an assembly automobile production line platform using sensitive sensors. A new prototype model is proposed using an extension of Petri nets called GR-TNCES (generalized reconfigurable timed net condition event systems). We also present a simulation of this model with a proposed tool ZIZO to show the energy gain compared to standard production line model.

This paper deals with the real-time scheduling in a reconfigurable multi-core platform powered by a rechargeable battery. A reconfiguration scenario is defined as an operation that allows the addition-removal-modification of tasks which may result in timing unfeasibility. Such a system may face several scenarios: i) increased power consumption that, in the worst case, may surpass the available energy budget, ii) increased computing demand, which may lead to the violation of real-time constraints, and iii) increased memory demand, potentially exceeding the provided memory capacity. To prevent these problems during the execution, a new scheduling strategy is necessary. The proposal is based on the assignment of tasks to different processor cores to satisfy these constraints simultaneously after any reconfiguration scenario. The effectiveness and performance of the designed approach are evaluated through simulation studies. An intelligent tool named Reconf-Pack is developed in our research laboratory to support this new proposed approach and to simulate it over randomly generated tasks.

This paper deals with reconfigurable wireless sensor networks (RWSN) in which a reconfiguration scenario is assumed to be any run-time adaptation of the software execution according to user requirements. We present a Reconfigurable Wireless Network Environment (RWiN-Environment) which is a visual tool allowing for designers to develop RWSN by starting from the initial specification and modeling of the architecture, then the required formal verification based on UPPAAL to verify temporal and functional properties described in user requirements. RWiN-Environment allows also the software design as well as the constraints validation by using an extension of OCL for optimization. The last step in the development process deals with the code generation and also the final deployment on STM32F4-based WSN. The developed tool is applied to a simulated case study in order to control an irrigation system in the agriculture domain.

This paper deals with the problem of scheduling multiprocessor real-time tasks by a hybrid genetic based scheduling algorithm. Nevertheless, when such a scenario is applied to save the system at the occurrence of hardware-software faults, or to improve its performance, some real-time properties can be violated at run-time. We propose a hybrid genetic based scheduling approach that automatically checks the systems feasibility after any reconfiguration scenario was applied on an embedded system. Indeed, if the system is unfeasible, the proposed approach operates directly in a highly dynamic and unpredictable environment and improves a rescheduling performance. This proposed approach which is based on a genetic algorithm (GA) combined with a tabu search (TS) algorithm is implemented which can find an optimized scheduling strategy to reschedule the embedded system after any system disturbance was happened. We mean by a system disturbance any automatic reconfiguration which is assumed to be applied at run-time: Addition-Removal of tasks or just modifications of their temporal parameters: WCET and/or deadlines. An example used as a benchmark is given, and the experimental results demonstrate the effectiveness of the proposed genetic based scheduling approach over others such as a classical genetic algorithm approach.

The paper presents a middleware implemented in Java, RT-MED, which corresponds to a software layer to be placed above the operating system. This software component is designed to execute and evaluate the performance, reliability and correctness of some real-time scheduling approaches which are theoretically validated. It describes a transition from the theory to the actual implementation of the proposed solutions. These solutions are based on a combinatorial optimization approach to solve the problem of feasibility in a system which is dynamically reconfigurable. RT-MED also presents a patch between the system and its environment under different constraints such as time and energy. It offers a set of adjustable parameters to control the flow of the execution. The middleware can be integrated into many operating systems and provides good quality both in terms of execution time and energy consumption. The implementation of this tool is based on java technology with embedded and real-time systems supported by the Real-Time Specification for Java. We have used a UML profile to describe various states and run-time reconfiguration of the embedded system. Results show that the middleware can effectively maintain the control and the stability of the system.

This paper is interested in the run-time adaptation of reconfigurable Multiprocessor System on Chip MPSoC architectures to their environment. A reconfiguration consists in the addition, removal or update of OS tasks to be executed in the different processors under real-time constraints. These tasks are with precedence constraints and exchange messages on the Network on Chip NoC that links different processors. Nevertheless, the intensive application of reconfigurations increases the frequency of the exchanged messages which become more and more important. The saturation problem of routers is then possible. We aim to prove by this research that all reconfigurable messages reach their target destinations and also respect their time constraints. Thus, the need to explore several paths instead of a faulty one is recommended. We propose a routing algorithm that allows a feasible real-time NoC after any reconfiguration scenario. This algorithm is split into two steps where the former deals with the look for minimal possible paths and the latter deals with a selected path that the messages will follow. This contribution is applied to a case study that we model by the formalism Reconfigurable Timed Net Condition Event System R-TNCES to verify temporal logic properties with the model Checker SESA.

This paper deals with the dynamic low-power reconfiguration of a real-time system. It processes periodic and probabilistic tasks that have hard/soft deadlines corresponding to internal/external events. A runtime event-based reconfiguration scenario is a dynamic operation allowing the addition/removal of the assumed periodic/probabilistic tasks. Thereafter, some tasks may miss their hard deadlines and the power consumption may increase. In order to reconfigure the system to be feasible, i.e., satisfying its real-time constraints with low-power consumption, this research presents a software-agent-based architecture. An intelligent agent is developed, which provides four solutions to reconfigure the system at runtime. For these solutions, in order to reconfigure the probabilistic tasks to be feasible, the agent modifies their temporal parameters dynamically; moreover, in order to feasibly serve the probabilistic tasks and reduce the system's power consumption, the agent provides three virtual processors by dynamically extending the periods of the periodic tasks. A simulation study verifies the effectiveness of the agent.

In the above paper [8, p. 733], there are errors inTheorem 1:

The paper deals with low-power adaptive scheduling of synchronous and flexible real-time OS tasks. A software reconfiguration scenario is assumed to be any run-time operation allowing the addition-removal-update of OS tasks to adapt the system to its environment under well-defined conditions. The problem is that any reconfiguration can push the system to an unfeasible behavior where temporal properties are violated or the energy consumption is possibly high and unacceptable. A task in the system can change its characteristics at any time when a reconfiguration scenario is applied, it can also be stopped or replaced by another one. The difficulty is how to find the new temporal parameters of the systems tasks after any reconfiguration. We use a DVS processor which is with a variable speed to support run-time solutions that re-obtain the system's feasibility. The challenge is how to compute the best combinations between available processor speeds for a good compromise between execution time and energy consumption. We propose a combinatorial optimization method based on integer programming and heuristics. We propose also a solution when the available speeds do not allow the feasibility of the system. Both approaches include a mechanism to adjust the deadlines of tasks to satisfy the feasibility conditions and overcome the problem of rejected tasks. This mechanism makes the scheduling more flexible and able to react in accordance with its environment.

This research paper deals with reconfigurable real-time systems to be adapted to their environment under user requirements. A reconfiguration scenario is a run-time software operation that allows the addition, removal and update of real-time OS tasks which can share resources and should meet corresponding deadlines. We propose a new Reconfigurable Priority Ceiling Protocol (denoted by RPCP) that avoids deadlocks after any reconfiguration scenario and changes the priorities of tasks in order to reduce their response and blocking times, and to meet their deadlines. This protocol requires the use of two virtual processors in order to guarantee the non-interruption of execution during the reconfiguration step. We develop a tool that encodes this protocol which is applied to a case study.

This paper1 deals with the dynamic reconfiguration of the frame packing as well as the traffic of real-time packets on a CAN network. This network is assumed to link distributed reconfigurable STM32F4 microcontrollers that can automatically add-remove-update periodic and aperiodic OS tasks at run-time. These tasks may exchange messages to be loaded in packets and to be sent on the network. After the addition of a pair of dependent tasks on two microcontrollers, a message should be added on CAN and should respect a corresponding deadline related to these tasks. After several additions of messages, some deadlines may be violated and the CAN may not support the added messages. In addition, the frame packing should be adapted at run-time to any reconfiguration scenario in the different microcontrollers. We propose a multi-agent based architecture to check the correct transmission of messages. If some deadlines are violated, these agents propose technical solutions for the feasibility of the whole system. They can suggest first the modification of periods or deadlines of tasks and messages. They can propose also the removal of some OS tasks or messages from the controllers according to their priorities. We propose in addition new solutions to construct the dynamic frame-packing while the bandwidth is minimized. A tool is developed at LISI and Cynapsys to support the different contributions of this paper.

This research paper deals with fault detections and dynamic recoveries of electrical smart grids that should be flexible and automatically adapted at run-time when faults occur on lines or devices. These grids are composed of three levels of power lines: High Voltage Lines (44KV), Medium Voltage Lines (11KV), and Low Voltage Lines (380V). In order to control the complexity of detection and deduction, we propose new relations between faults. We define also a multi-agent architecture to allow dynamic recoveries where two types of agents are defined: static agents and mobile agents. Static agents have as a task the detection of local faults on power lines and the recovery of their normal behaviors by using a local knowledge-base. The mobile agents are created to dynamically move on lines and to find new solutions when no local solution is found. To validate and test our approach, we present experimental results showing the originality of the paper's contribution by assuming a case study.

The paper deals with the modeling and verification of B method-based reconfigurable control systems. Reconfiguration means the dynamic changes of the system behavior at run-time according to well-defined conditions to adapt it to its environment. A reconfiguration scenario is applied as a response to improve the system's performance, or also to recover and prevent hardware/software errors, or also to adapt its behavior to new requirements according to the environment evolution. A new extension called Reconfigurable B “R-B” is proposed to specify reconfigurable control systems. It consists of two modules: Behavior and Control. The first defines all possible behaviors of the system, and whereas the second is a set of reconfiguration functions applied to change the system from a behavioral configuration to another one at run-time. We verify a reconfigurable control system by using the B method. The goal is to guarantee the consistency and the correctness of the abstract specification level. The second contribution of this paper deals with the verification of the reconfigurable system by avoiding redundant checking of different behaviors sharing similar operations. In order to control the complexity of verification, an optimal algorithm is developed and a prototyped tool called “Check R-B” is implemented. The paper's contribution is applied to a benchmark production system FESTO.

The article deals with Distributed Multiagent Reconfigurable Embedded Control Systems following the International Industrial Standard IEC61499 in which a Function Block (Abbreviated by FB) is an event-triggered software component owning data and a control system is a network of distributed blocks. We define a multiagent embedded architecture in which a Reconfiguration Agent is affected to each device of the execution environment to apply local reconfigurations, and a Coordination Agent is proposed for coordination between devices in order to guarantee safe and coherent distributed reconfigurations. A Communication Protocol is proposed to handle such coordination by using well-defined Coordination Matrices . A prototype is developed to simulate the whole architecture when faults occur or system’s optimizations are applied. We specify Reconfiguration Agents to be modeled by nested state machines, and the Coordination Agent according to the formalism Net Condition/Event Systems (Abbreviated by NCES) which is an extension of Petri nets. To allow correct and coherent distributed reconfigurations, we check all possible interactions between controllers by verifying that whenever a reconfiguration is applied in a device, the Coordination Agent and other concerned devices react as described in user requirements. We propose finally XML-based implementations of both Coordination and Reconfiguration Agents according the the technology IEC61499. The article’s contributions are applied to two Benchmark Production Systems available in our research laboratory.

No abstract available.

No abstract available.

This study deals with the formal modeling and verification of reconfigurable discrete event control systems (RDECSs). The behavior of an RDECS is represented by that of control components (CCs) and the communication among them. A new formalism, called Reconfigurable Timed Net Condition/Event Systems (TNCES) (R-TNCES), is proposed for the optimal functional and temporal specification of RDECS, which is defined by a behavior module and a control module. The former is a union of various superposed TNCESs, where TNCES-based CC modules are basic units. The latter is a set of reconfiguration functions dealing with the automatic transformations of these TNCESs in response to errors or user requirements by enabling or disabling CC modules, changing condition signals and/or event signals among them, and also treating the state feasibility before and after reconfigurations. To control the verification complexity of R-TNCES, a layer-by-layer verification method is developed, where the similarities of different TNCESs in the behavior module are considered. The contribution of this original paper is applied to a benchmark production system.

Presents corrections to the second paragraph of Section V-B in the above titled paper (ibid., vol. 8, no. 2, pp. 374-393, Apr. 2011).

This study deals with deadlock problems in a system with uncontrollable and unobservable events, which is modeled with a subclass of Petri nets. We design monitors to enforce constraints for minimal siphons in a Petri net model. A key point of this paper is how to select the input and output arcs of a monitor when there exist uncontrollable and unobservable transitions. After the enforcement of constraints, an iterative algorithm is developed to obtain a controlled system with liveness. A sufficient and necessary condition is established to decide the existence of a monitor enforcing a constraint in a plant with uncontrollable and unobservable transitions.

Deadlock prevention plays an important role in the modeling and control of flexible manufacturing systems (FMS). This paper presents a novel and computationally efficient method to design optimal control places, and an iteration approach that only computes the reachability graph of a plant Petri net model once in order to obtain a maximally permissive liveness-enforcing supervisor for an FMS. By using a vector covering approach, a minimal covering set of legal markings and a minimal covered set of first-met bad markings (FBM) are computed. At each iteration, an FBM from the minimal covered set is selected. By solving an integer linear programming problem, a place invariant is designed to prevent the FBM from being reached and no marking in the minimal covering set of legal markings is forbidden. This process is carried out until no FBM can be reached. In order to make the considered problem computationally tractable, binary decision diagrams (BDD) are used to compute the sets of legal markings and FBM, and solve the vector covering problem to get a minimal covering set of legal markings and a minimal covered set of FBM. Finally, a number of FMS examples are presented to illustrate the proposed approaches.

The paper deals with reconfigurable embedded control systems following different component-based technologies and/or Architecture Description Languages used today in industry. We define a Control Component as a software unit to support control tasks of the system, which is assumed to be a network of components with precedence constraints. We define an agent-based architecture to handle automatic reconfigurations under well-defined conditions by creating, deleting, or updating components to bring the whole system into safe and optimal behaviors. To cover all possible reconfiguration forms, we model the agent by nested state machines according to the formalism Net Condition/Event Systems (NCESs), which is an extension of Petri nets. In addition, we apply a model checking to verify functional and extra-functional properties according to the temporal logic "Computation Tree Logic” (CTL). The goal is to check the agent reactivity after any evolution of the environment. Several complex networks can implement the system, where each one is executed at a given time when a corresponding reconfiguration scenario is automatically applied by the agent. To check the correctness of each one of them, we apply in several steps a refinement-based approach that automatically specifies feasible Control Components according to NCES. The model checker SESA is automatically applied in each step to verify deadlock properties of new generated components, and it is manually used to verify CTL-based properties according to user requirements. We implement the reconfiguration agent by three modules that allow interpretations of environment evolutions, decisions of useful reconfiguration scenarios, and finally, their applications. Two Industrial Benchmark Production Systems FESTO and EnAS available in our research laboratory are applied to explain the contributions of the paper.

This paper deals with distributed multi-agent reconfigurable embedded control systems following the International Industrial Standard IEC 61499 in which a Function Block (FB) is an event-triggered software component owning data and a control application is a network of distributed blocks that should satisfy functional and temporal properties according to user requirements. We define an architecture of reconfigurable multi-agent systems in which a Reconfiguration Agent is affected to each device of the execution environment to apply local reconfigurations, and a Coordination Agent is proposed for coordinations between devices in order to guarantee safe and adequate distributed reconfigurations. A communication protocol is proposed to handle coordinations between agents by using well-defined Coordination Matrices. We specify both reconfiguration agents to be modeled by nested state machines, and the Coordination Agent according to the formalism Net Condition-Event Systems (NCES) which is an extension of Petri nets. To validate the whole architecture, we check by applying the model checker SESA in each device functional and temporal properties to be described according to the temporal logic “Computation Tree Logic.” We have also to check all possible coordinations between devices by verifying that whenever a reconfiguration is applied in a device, the Coordination Agent and other concerned devices react as described in user requirements. The paper's contributions are applied to two Benchmark Production Systems available in our research laboratory.

This paper addresses a component-based approach using the Event-B method to develop automated systems. These systems are composed of two parts: the control part (controller) and the operative part (controlled component). The first is a software component which controls the operative part that models the physical device and its environment. We propose in this paper the use of the formal Event-B method to develop automated systems applying a codesign technique, where the two components are developed separately, and then, a composition is defined with the Event-B method to prove the automated system correctness. First of all, we define a specification for the composition of these two components in the Event-B method. Second, we give refinement semantics for a component-based system before proposing a method to verify the refinement of a whole system from that of its components.

The paper deals with reconfigurable software component-based embedded control systems. We define a Control Component as a software unit to support control tasks of the system which is assumed to be a network of components with precedence constraints. We define an agent-based architecture to handle automatic reconfigurations under well-defined conditions by creating, deleting or updating components to bring the whole system into safe and optimal behaviors. We model the agent by nested state machines where states correspond to other state machines in order to cover all reconfiguration forms. Several complex networks can implement the system where each one is executed at a given time when a corresponding reconfiguration scenario is automatically applied by the agent. To check the correctness of each one of them, we apply in several steps a refinement-based approach that automatically specifies feasible Control Components according to the formalism Net Condition/ Event Systems (abbr. NCES) which is an extension of Petri nets. The model checker SESA is automatically applied in each step to verify deadlock properties of new generated components, and it is manually used to verify CTL-based properties according to user requirements. Two Industrial Benchmark Production Systems FESTO and EnAS available in our research laboratory are applied to explain the paper contribution.

This paper1deals with the model checking of Safe Heterogeneous Embedded Control Systems following different component-based technologies or implemented according to different Architecture Description Languages (ADL) used today in industry. The purpose is to reduce their time to market by exploiting various execution environments and different rich libraries. A ¿Control Component¿ is defined in our research work as an event-triggered software unit composed of an interface for any external interactions and an implementation allowing control actions of physical processes. A control system is assumed to be a composition of components with precedence constraints to control the plant according to well-defined execution orders. We define an agent-based architecture where the agent controls the environment evolution and applies automatic reconfigurations when hardware errors occur at run-time to guarantee a functional safety of the whole system. We model the architecture according to the formalism Net Condition/Event Systems (abbr. NCES), and apply the model checker SESA to check functional properties described according to the well-known Computation Tree Logic (abbr. CTL). Our purpose is to check that whenever an error occurs at run-time, the agent behaves as described in user requirements by activating Control Components and deactivating others to guarantee a functional safety of the whole system. A Benchmark Production System is used in this research work to explain our contribution.

The paper deals with the implementation of reconfigurable embedded control systems following the Component-based International Industrial Standard IEC61499, in which a Function Block is an event triggered software component owning data and an application is a composition of blocks. To handle automatic reconfigurations of the whole system, we define an agent-based architecture such that the agent checks and interprets the environment evolution before creates, updates or deletes Function Blocks according to well-defined conditions. It is composed of three modules: the interpreter that interprets the environment evolution, the engine that decides new reconfigurations according to such evolution and the converter that applies agent decisions. A Benchmark Production System is used to explain our contribution, and technical solutions are proposed to implement its different agent modules.

This paper deals with automatic refinement-based specifications of feasible Control Tasks in Embedded Control Systems. By considering the Plant architecture, we model at first time the system with an abstract model according to the Net Condition Event System formalism and we automatically refine thereafter this model in different steps to define and specify Control Tasks that have to be checked in each step. This approach optimizes the development cost of complex Embedded Systems and it is applied on two Benchmark Production Systems FESTO and EnAS available in our research laboratory to prove its benefits.

This paper deals with the development of reconfigurable control systems following the component-based International Industrial Standard IEC61499. In this standard, a function block is an event-triggered component owning data and an application is a FB network that has to satisfy temporal properties. This network is totally changed or modified if a reconfiguration scenario is applied at run-time. We classify at first time all possible reconfiguration forms and we propose thereafter an Agent-based architecture to handle them. To verify temporal properties on the FB network corresponding to each reconfiguration scenario, we analyze the schedulability of the corresponding blocks. If it is feasible, then a static scheduling is generated as a sequencing to be used by the OS when the Agent applies at run-time the corresponding scenario. We deduce finally the whole system feasibility if the FB network corresponding to each possible scenario is feasible. A tool X - Reconfig is developed in our research laboratory to support the paper contribution.

This paper deals with the IEC 61499 standard. A function block (FB) is an event triggered component and an application is a distributed FBs network on several devices. We consider these devices as multi-tasking PLCs. To validate the temporal behavior inside a device, we propose a hybrid scheduling approach combining off-line and on-line policies. This approach transforms application blocks into tasks thanks to the off-line policy. Then, it checks their required on-line feasibility. On the other hand, we propose also a temporal characterization of exchanged messages between devices to check also their online feasibility.

OPC-XML defines a standard method for accessing automation data in the industry field. This protocol relies on Web service communications allowing a great compatibility and a software/hardware independent definition. Nevertheless, this underlying protocol does not take into account temporal Quality of Service. Therefore, when a contract is defined between the client and the server, its execution has to be monitored to check if expected temporal properties are respected. In this paper, we propose to enrich the contract definition in order to define mandatory and optional quality of service. We propose an observation mechanism for the network congestion detection. Thanks to this information, it is possible to dynamically adapt the QoS to preserve the mandatory properties