Nowadays, Cyber-Physical Systems (CPS), particularly drones, play a pivotal role in environmental research. Scientists depend on these platforms to monitor various sensor data and ensure comprehensive data archiving. However, despite their advantages, researchers encounter several challenges, including communication limitations and the complexity of setting up systems tailored to their needs. To address these issues, we propose MoDD, a model-driven data collection framework based on a customized publish/subscribe model. MoDD simplifies the development and configuration of data collection systems. It offers scientists a solution that meets their specific needs, allowing them to focus on high-level requirements while the framework manages the underlying complexities. We demonstrate the effectiveness of MoDD through practical evaluations on an actual Unmanned Surface Vehicle. Additionally, results show a 79% reduction in throughput (drone to base station link) compared to existing publish/subscribe systems.

One primary objective of drone simulation is to evaluate diverse drone configurations and contexts aligned with specific user objectives. The initial challenge for simulator designers involves managing the heterogeneity of drone components, encompassing both software and hardware systems, as well as the drone’s behavior. To facilitate the integration of these diverse models, the Functional Mock-Up Interface (FMI) for co-simulation proposes a generic data-oriented interface. However, an additional challenge lies in simplifying the configuration of co-simulation, necessitating an approach to guide the modeling of parametric features and operational conditions such as failures or environment changes. The article addresses this challenge by introducing CARES, a model-driven engineering and component-based approach for designing drone simulators, integrating the FMI for co-simulation. The proposed models incorporate concepts from component-based software engineering and FMI. The NAVIDRO architectural style is presented for designing and configuring drone co-simulation. CARES utilizes a code generator to produce structural glue code (Java or C++), facilitating the integration of FMI-based domain-specific code. The approach is evaluated through the development of a simulator for navigation functions in an autonomous underwater vehicle, demonstrating its effectiveness in assessing various autonomous underwater vehicle configurations and contexts.

Scientists who analyze physical phenomena usually work on data coming from various sensors spread over the environment. Visualization of these data is a key issue in this process. In addition, these data are massive and provided at a very high rate. Under these conditions, it can be a real challenge to efficiently implement a reliable, dedicated, and itself efficient visualization tool, especially without the support of a large scale platform. In this paper, we propose to take up this challenge with FaST: a model-driven framework which makes it possible to generate a complete solution for the storage, the querying and the visualization of time series in a big data context. The specification of the solution is efficient thanks to a dedicated language intended for data scientists. It enables a simple description of both the architecture of the solution and the data it has to handle. Deployment is efficient thanks to code generation and server-side dockerization. The generated tool is efficient thanks to the implementation of ad hoc optimizations. On server-side, they come from pre-computation of views based on the Min-Max principle. On client-side, they come from the anticipation of queries related to the data navigation abilities of the generated tool. The underlying principles of FaST and its optimizations are detailed in this paper, as well as its implementation and its performance evaluation. It highlights a significant gain in execution time, with a limited database overhead.

One key objective of Cyber-Physical System (CPS) simulation is to evaluate different CPS configurations regarding a certain user objective. First, simulation of CPS necessitates frameworks to handle heterogeneity of CPS components (the software and hardware system control, the behavior of the CPS itself and its physical environment). Then, to build simulators, designers use paradigms like FMI (Functional Mock-Up Interface) that proposes a data-driven generic interface facilitating the integration of heterogeneous models. However, in order to facilitate simulation configuration, an approach is required to drive modeling of parametric features and operational conditions. In this paper, we present CARES, a component-based and model-driven approach to facilitate CPS simulation. CARES is applied to evaluate an Autonomous Underwater Vehicle (AUV) navigation function by simulation. The proposed models integrate both the principles of a generic simulation (integration of Component Based Software Engineering CBSE concepts and FMI paradigm) and domain specific aspects through a component-based architecture style. From a design model, a code generator builds the structural (Java or C++) code of the simulator. The generated code relies on a given run-time library for its execution and its structure facilitates integration of domain-specific code. The experiments show the effectiveness of the approach to build simulators for evaluation of different AUV configurations.

Cyber-physical systems evolving in uncertain environment endure fluctuating dynamics during their lifetime. In such a variable context, controlling systems towards safety and system performances is challenging. In particular, controller tuning (finding optimal control parameters) is a challenging process due to the multiplicity of contexts to be considered. In this paper, we use a combination of model-driven simulation, dimensionality reduction, clustering and prediction techniques to define adequate control parameter settings. First, we propose to explore the controller behavior by simulating different configurations, a configuration is defined by a context (controlled process, environment, sensors, actuators) and a control parameters setting. From simulation results, a discretization is performed by binning the evaluation of quality of control. Then, we apply feature selection algorithms to identify contextual parameters that have a significant impact on performances of the controller. Considering only selected parameters, we finally carry out a clustering aiming at identifying for context domains an optimal control parameter setting. The approach is iterative to define the boundaries of the controller for a given context domain. For non simulated contexts, we propose a prediction module based on regression techniques.To evaluate the proposed approach, we compare it with classical control theory and we apply it to a proportional controller used for a leader/follower application. The experiment shows effectiveness in the identification of control parameters setting for different contexts.

International audience

To improve the quality, the performance and the real-time correctness of embedded real-time systems, one main design activity is the deployment consisting on mapping functions to tasks and tasks to processors. Several deployment strategies have been proposed by the literature. Each of them is well adapted for one deployment step, one optimization criterion and one type of application. But for realistic systems and general case, none of them is optimal. This paper presents a model-based approach to facilitate the integration and the composition of different deployment strategies. The framework allows to combine different strategies for different parts of the system, and to apply consecutively different strategies. To compare different compositions of strategies, evaluations are proposed based on a set of real-time, performance and design quality criteria. The library of strategies and evaluation criteria may be easily extended by respecting a generic API. Evaluation on case studies shows the interest of combining several strategies to optimize different criteria like real-time and quality of design criteria.

To reduce the gap between high-level functional descriptions and real-time multitasking implementation, this paper proposes a set of modeling and code generation principles. Modeling principles are based on integration of a specific BIP concurrent component. This component follows a specific behavioral pattern based on periodic activation of data consumption, data processing and data production. It acts as a periodic task at execution stage. The pattern proposes two variants for eventtriggered and time-triggered platforms. The approach has been tested on three case studies, showing the interest of formalization for behavioral verification. The proposed pattern allows real-time validation and offers classical advantages of high-level modeling.

International audience

The legacy code of a tool handling domain specific data gathers valuable expertise. However in many cases, it must be rewritten to make it apply to structurally incompatible data. We investigate a co-evolution approach to avoid this update by making the call context meet the a legacy tool definition domain. The data conforming to the call context co-evolve into data conforming to the definition domain. Once processed by the tool, they can be put back into their original context thanks to a specific reverse transformation which enables the recovery of elements that had been initially removed. This approach is applied to Orcc, a compiler for dataflow applications. Orcc requires many common functions that are expected to be adapted to its own context. Our approach is an effective way to reuse them instead of rewriting them.

This paper puts the focus on adaptable model migrations. A dedicated formalism is introduced to combine automatically-generated migrations with custom-made migrations. To illustrate this issue and the approach we suggest to address it, a prototype engine is presented. Then, the prototype is applied on a case study. The prototype processes the migration specifications that have been automatically generated and then customized. The case study consists of the reuse of a mapping tool, in order to change highlighted places. During the reuse process the migration specification is customized in order to produce different migrated models.

In home network, to manage network bandwidth usage, one solution is to control the server outgoing traffic with a token bucket policy. Hull-based token bucket parameter setting allows the guarantee of Quality of Service for variable bitrate video streaming. Hull is an abstraction of the bitrate, following the bandwidth requirement evolution dynamically. In the case of multi-streaming, we investigate a shifting technique to reduce the peaks impact. Postponing the streaming starting time of a video helps to decrease the maximum required bandwidth. The technique is then mixed with the hull-based reservation. Simulations show the effectiveness of the combined approaches to optimize bandwidth usage, guaranteeing the best QoS for streaming. Online utilization is also discussed.

Modern development methodologies from the industry and the academia for complex real-time systems define a stage in which application functions are deployed onto an execution platform. The deployment consists of the placement of functions on a distributed network of nodes, the partitioning of functions in tasks and the scheduling of tasks and messages. None of the existing optimization techniques deal with the three stages of the deployment problem at the same time. In this paper, we present a staged approach towards the efficient deployment of real-time functions based on genetic algorithms and mixed integer linear programming techniques. Application to case studies shows the applicability of the method to industry-size systems and the quality of the obtained solutions when compared to the true optimum for small size examples.

The synthesis of a valid and optimized deployment model from functional and platform models is a crucial issue in the development of distributed real-time systems. The synthesis consists in the allocation of functions/signals to execution nodes/communication buses, the mapping of functions/signals into tasks/messages and the priority assignment to tasks/messages. Current approaches provide partial solutions for the synthesis of a deployment model on distributed platforms, as either the allocation or the mapping is fixed a-priori. In order to tackle this problem we propose an optimization technique, based on two different mathematical programming formulations, to handle optimization of both allocation and mapping. The optimization is multi-objective and considers extensibility maximization, latency minimization and minimization of the number of tasks. The obtained solutions satisfy timing and platform resources requirements. An automotive case study shows the effectiveness of our approach.

In this paper we present a network resource management framework, based on an home network model, that ensures the QoS (Quality of Service) of distributed multimedia applications. The latter are deployed, on the user demand, on the heterogeneous devices and the heterogeneous communication links of the home network. The resource management framework contains dedicated components to estimate the required network bandwidth of a specific multimedia application, the currently available network bandwidth and to reserve the required network bandwidth. This paper evaluates the resource management framework on a real home network with Wifi links that support 802.11e network QoS standard and with Wifi links that do not.

This paper presents a framework to provide the right amount of resources to legacy multimedia application. Thus, these applications will provide the expected user-level QoS. When starting a multimedia application, the proposed framework provides admission control services for CPU reservation on all the devices used. The reservations are handled by broker components. The brokers use underlying operating system's mechanisms to start and stop reservations. Classically, devices of the home network make use of a General Purpose Operating System such as Linux. A lot of work has been done to integrate real-time schedulers in Linux or to provide distributed resource management frameworks. However it exists no solution that estimates, reserves and guarantees the quantity of CPU for multimedia applications. Moreover, modifying the devices' operating system may not be possible. Hence we propose a framework that supports both the standard Linux kernel and classical real-time scheduler. We evaluate the CPU resource management framework by testing multimedia applications, together with a stress on the CPU, on PCs and embedded devices (beagle boards).

In this paper we present our approach to cope with platforms' heterogeneity of the home network. Traditional resource reservation policies, based on a mapping table, associate one Quantity of Resource (QoR) to one platform resulting in large table size. To reduce this size, we propose to use aggregated mapping tables to associate one aggregated QoR to several platforms. This reduction facilitates resources management for multimedia applications in home networks. This paper presents the aggregation algorithm which automatically builds aggregated mapping tables, with input criteria given by content providers. The algorithm uses clustering coupled with domain knowledge. It is evaluated with randomly generated mapping tables.

This paper deals with embedded systems software and the modification of its architecture and behavior at execution-time. Incautious implementation of these features demands both heavy memory and performance overrun. To accomplish such software evolution activities in resource-constrained embedded systems, we propose a component-based run-time evolution infrastructure that reconciles richness of evolution alternatives and performance requirements. Our proposal is based on off-site components reifications, which are representations of components that allow us to treat evolution concerns remotely. Hence, the workload to be processed by the embedded device is alleviated. Memory and processor-time resources consumption evaluation on a real-world scenario show the efficiency and pertinence of our approach.

This presentation demonstrates the early results from the French ANR project RT-Simex. RT-Simex proposes a set of tools to analyze parallel embedded code and trace the simulation results back to the initial models from which the code was generated. The whole tool-set relies on standard formats (UML MARTE, Open Trace Format) to ensure a perennial use. The main difficulty is to reconcile different execution traces extracted from codes running concurrently on different unsynchronized platforms. This is achieved through the polychronous logical time model of MARTE.

Recent work on component-based software design has proved the need of resource-accurate development of embedded software. In the more specific cases of mobile systems, the developer also needs tools to facilitate the adaptation of functionalities to resources (lack of memory or bandwidth, etc.), and also to evaluate the performance w.r.t. the resource issues. As we want to design and develop at the same time the application and its resource controllers, we chose to use Qinna, which was designed to manage resource issues (specification, contractualization, management) during the development process of such an application. We propose a complete formalization of the resource constraints specification, through the use of a variant of the event-based logics, MEDL and PEDL. Qinna then automatically performs the runtime resource assurance. We illustrate this work in a case study.

As functionalities required by embedded systems increase, higher levels of abstraction become necessary to fulfill development exigencies. At the same time, traditional physical and economical constraints such as size, memory usage and energy consumption subsist, making embedded systems development even more complex as it must face two contradictory requirements. In this paper, we expose how a component-based development framework is able to support these two conflicting demands. We follow a component-based approach to benefit from reusability and separation of concerns at design-time, producing flexible systems. We propose a set of flexibility-oriented properties allowing architects to generate, for a same architecture, a set of systems with different flexibility capabilities; these optimization techniques allow developers to pay for flexibility only where it is actually desired. Experiments conducted on several use-cases confirm the effectiveness of our approach.

Wormhole attacks enable an attacker with limited resources and no cryptographic material to disrupt wireless networks. In a wormhole attack, an attacker records packets (or bits) at one location in the network, tunnels them (possibly selectively) to another location and retransmits them there into the network. In this paper, we present an algorithm for detecting and thus defending against wormhole attacks in wireless multi-hop networks. This algorithm uses only local and neighborhood information without requiring clock synchronization, location information or dedicated hardware. Moreover, the algorithm is independent of wireless communication models. We present simulation results for grid-like topologies and for random topologies and show that the algorithm is able to detect wormhole attacks in all cases whereas the number of false alarms (false detections) decreases rapidly if the network is sufficiently dense.

This document presents a simulation-based method for the development of real time embedded systems. This kind of system is really sensitive to the communication with external environment and the Quality of Service (QoS) provided by the used target. So, the method is MDA-based and proposes to separate the concerns, introducing a communication layer with the outside environment, an application layer and a connection layer between these two layers. Then, it is possible to emulate each part on the system in order to validate it.

This document presents a MDA-based method for the development of systems dedicated to process control. It proposes to introduce a first sensors/actuators independent model. QoS semantic definitions are then stated; thus, dealing with quality of service (QoS) requirements is a way to safely introduce sensors/actuators in the model.

This paper proposes a method for temporal verification of real-time multitasking applicationproperties based on a communicating timed automata IF language. The properties are divided into two kinds: local properties of application elements like object creation/destruction, object length, task deadlocks and secondly global properties such as data age, deadline, and time interval verification. These properties are represented by observer automata and verified by the IF2C tool exhaustive simulation. The notion of phrase is used to reduce the IF representation graph by partitioning the application on the basis of phases.

The purpose of this work is to provide an iterative method of task temporal parameter adjustment in order to select the fitting characteristics for all the tasks obtained during the architectural design phase. The authors present a method to analyse and to set the temporal parameters of tasks in a rate monotonic scheduling environment. They introduce a graphical representation for tasks based on a classical temporal model. This approach is particularly useful in situations in which the designer has to build task set parameters iteratively, to add a task to a set of tasks with already fixed parameters or to modify the task parameters in order to improve time characteristics. This methodology permits the designer to enhance the temporal performance of the application in terms of task response time, processor idle time, number of processor context switches, etc.