Henrick Deschamps

Gerlando Cappello

Janette Cardoso

Pierre Siron

Coincidence Problem in CPS Simulations: the R-ROSACE Case Study

Keywords: Aeronautics, CPS, ROSACE, Modelling, Simulation, Scheduling, HLA, CERTI

This paper presents ongoing work on the formalism of Cyber-Physical Systems (CPS) simulations.

We focus on a distributed simulations architecture for CPS, where the running simulators exist in concurrent and sequential domains. This architecture of simulation allows the expression of structural and behavioral constraints on the simulation. We call scheduling of simulation the temporal organization of the simulators interconnection.

In this paper we address the problem of the interconnected simulations representativity. To do so, we highlight the similarities and differences between task scheduling and simulation scheduling, and then we discuss the constraints expressible over that simulation scheduling. Finally, we illustrate a constraint on simulation scheduling with an extension of the open source case study ROSACE, implemented with CERTI, a compliant High-Level Architecture (HLA) RunTime Infrastructure (RTI). HLA is an IEEE standard for distributed simulation.

I. INTRODUCTION

The aeronautical sector is subject to long and expensive development cycles, especially on avionic products, corresponding to a significant part of the development costs of a civil aircraft. One of the main objectives of the aeronautical industry is to identify and correct system design errors as soon as possible. Using simulation during the development and integration lifecycle of an avionics product is one answer to this need, as long as the simulation sufficiently reflects reality.

Aircraft are systems including controllers tightly interacting with the environment to stabilize the vehicles, which are defined as Cyber-Physical Systems (CPSs) [START_REF] Landauer | Flight Systems are Cyber-Physical Systems[END_REF]. Thus, aircraft simulations require the interaction of avionics simulations with environment simulations. Due to the complexity of the simulated systems and the simulated environments, as well as the need of incrementally improve systems one by one, simulations are more and more modular, composed of smaller simulations.

We consider that every modular component of the simulation is sufficiently representative. For that, we rely on the existing knowledges in model engineering, these skills can be different if the model represents a physical part or a cyber part. Also, we do not address the problem of parallelization, or of the distribution of large model simulations, our starting point is a set of components produced by experts in model engineering and distributed simulation engineering. With these components, certain abstracted constraints and degrees of freedom are expressed for the integration. Certain very hard constraints for strong coupling during the solving of a set of complex equations will be considered in the future.

With these hypotheses, our problematic is the composition of the existing simulation components that reflect at best the reality. This is a contribution to simulation integration engineering.

Our approach is to propose in section III a formalism supporting the description of the simulation components and the logical model scheduling to be executed. Then we propose in section IV another formalism for the targeted execution architecture. This formalism is generic; section V describes an implementation using HLA-CERTI, but any other implementation could be used. In section VI, we focus on some simulation constraints: Logical latencies and in particular the coincidence constraint. Section VII presents R-ROSACE, a representative aeronautics application that allows to validate our approach. The simulation results illustrate the impact of coincidence problem in the cyber part of the CPS. Conclusions are discussed in section VIII.

II. RELATED WORK

The simulation of Cyber-Physical Systems touch many research and engineering1 domains and is needed at different steps in its design as represented in fig. 1. The simulation focus can be more: -a) on the physical side: The lack of analytical solution for complex systems needs a simulation phase whose goal is to approximate the behavior of the complex physical phenomenon as faithfully as possible [START_REF] Feki | Distributed real-time simulation of numerical models : application to power-train[END_REF]; or -b) on the cyber side: it is necessary to simulate the control to be embedded in the CPS from the earlier stage until the simulation of the computer itself. The simulation of physical systems always involves discretization of some type of continuous (or hybrid) model described by differential equations. A good survey about modeling and simulation of CPS is presented in [START_REF] Feki | Distributed real-time simulation of numerical models : application to power-train[END_REF]. Concerning the modeling, the Ordinary Differential Equation (ODE) in fig. 1 may be replaced by Partial Differential Equation (PDE) or Differential Algebraic Equation (DAE). As for the simulation, differential equations can be solved by discretizing the time (using, e.g., Runge-Kutta algorithms) or discretizing the state values (using Quantized State System (QSS) algorithms). If the model is quite complex, then parallelization is an interesting solution for speed-up a simulation and/or to avoid model simplification.

A key point then is how to decouple models with ODE and DAE, which are strongly sequential by nature. One approach consists in using Transmission Line Modeling (TLM) [START_REF] Sjölund | Towards efficient distributed simulation in modelica using transmission line modeling[END_REF] [START_REF] Khaled | Fast multi-core cosimulation of cyber-physical systems: Application to internal combustion engines[END_REF].

Another aspect to point out concerning simulation is that more and more co-simulation is needed, providing interoperability, exchange and reusability of simulations. Two standards exist, with different characteristics: Functional Mock-up Interface (FMI) and High-Level Architecture (HLA). HLA [START_REF]IEEE standard for modeling and simulation (M & S) high level architecture (HLA): object model template (OMT) specification[END_REF] is a IEEE standard originally developed for distributed military simulations and it was not real-time. However, nowadays, HLA is also used in real-time simulation as in [START_REF] Gervais | Real-time distributed aircraft simulation through HLA[END_REF] [8] [START_REF] Chaudron | How to solve ODEs in real-time HLA distributed simulation[END_REF]. FMI is a tool independent standard to support both model exchange and co-simulation of dynamic models, as for today under the roof of the Modelica Association [START_REF]Functional mock-up interface (fmi)[END_REF]. The standard allows distributed simulation but it is up to the user to provide the way to do so. Some work, as [11] [12] propose to combine both standards HLA and FMI.

III. CHARACTERIZATION OF THE MODEL SCHEDULING A. Model scheduling and task scheduling

This section clarifies the concept of "model scheduling" in CPS simulation.

CPS are systems, often complex, composed of multiple systems and interacting with an environment. A simulation of CPS is a simulation of the cyber part, tightly interacting with the simulation of the physical part. A simulation of CPS comprises the assembly of the cyber part inserted in the simulation framework, and a discretization of the physical part, as illustrated in fig. 2.

These simulations are not necessarily monolithic. A simulation of a system composed of multiple systems can be divided into a simulation of the system components. For instance, a simulation of an aircraft can be divided into the simulation of the engines, the simulation of the structures, the simulation of the rudder, etc. . . This distribution is particularly adapted to systems where the components can evolve quickly and independently, and when "hardware in the loop" is needed. Model scheduling is defined in [START_REF] Deschamps | Toward a formalism to study the scheduling of Cyber-Physical systems simulations[END_REF] as the temporal organization of components periodical execution and the synchronization of their interactions. In model scheduling, we call dataflow the flow of data produced by components and consumed by others. A dataflow is either a direct data production and consumption between two close models, or a sequence of data produced and consumed by components between two distant components.

Model scheduling could be brought closer to task scheduling. The periodical execution of component is similar to the scheduling of periodical tasks, except that a component execution instance can be divided in three steps: the data consumption, the computation, and the data production. Furthermore, the notion of the deadline is not refined yet, but we consider it to be the next component iteration for the sake of simplicity. Fig. 3 illustrate the similarity between task and model scheduling. More specifically, a component is equivalent to a task, and components can be run sequentially or concurrently by logical processors. An example of execution architecture is given in section IV.

Nevertheless, model scheduling and task scheduling have major difference, described in the two following subsection.

B. Dataflow and precedence

In task scheduling, one of the most major constraints is the precedence constraint. This constraint is defined in [START_REF] Lamport | Time, clocks, and the ordering of events in a distributed system[END_REF] as a relation between two activities i and j, by i → j, meaning j cannot start before i.

A priori, the communication between simulation components can be converted into precedence constraints. For instance, if a component A produces data consumed by a component B, then A must be executed before B. But the problem is more complex with CPS scheduling.

In CPS systems, there are algebraic loops. With the previous example, A can produce a data for B, and B for A. These algebraic loops lead to two conflicting constraints. The solution is to find a precedence constraint that can be relaxed in an algebraic loop and to break the loop. For instance, if the data produced by B for A can be delayed, then the precedence constraint between B and A is removed.

Nevertheless, in complex systems such as aircraft, algebraic loops are common, and some systems are implied in multiple loops. The dataflows are much more similar to a mesh than a ring, as illustrated in fig. 4. The relaxation of precedence constraints comes from the simulated systems requirements and environment modelers specialists. Systems, such as avionics, are designed to tolerate certain delays when exchanging data, and environment modelers might design simulation components to tolerate delays. More specifically, minimum and maximum latencies can be associated with data exchanged between two components in a simulation, as well as a long datapath between two components separated by multiple components. As long as those latencies are respected, precedences can be set, and the simulation will still be representative.

IV. AN EXECUTION SIMULATION ARCHITECTURE

We consider an execution architecture named Simulation Execution Architecture (SEA) and defined in [START_REF] Deschamps | Toward a formalism to study the scheduling of Cyber-Physical systems simulations[END_REF]. In the SEA, there is a double level of scheduling, a global scheduler scheduling logical processors using local schedulers, illustrated in fig. 5. Logical processors, running in a concurrent domain, can execute periodic tasks. Tasks are executed sequentially on logical processors. It has to be noted that the global scheduler does not have information about the tasks scheduled by its logical processors, and cannot give an order between two tasks. There are two kinds of communications, intraprocessor and interprocessor communications. Independently of the nature of the communications (shared memory, variables, messages. . . ), those two kinds of communications have different properties:

• Intraprocessor communication allows tasks in the same logical processor exchanging information directly. • Interprocessor communication allows tasks in different logical processors exchanging information on logical processors synchronization points, under the direction of the global scheduler. In the SEA architecture, the components of a simulation are statically associated to tasks for the simulation execution. After the association, the periods of the tasks are set to the period of the components.

In [START_REF] Chaudron | Architecture de simulation distribuée temps-réel[END_REF], examples of simulation executions are given, illustrated with HLA. In HLA, a distributed simulation is composed of simulations, called federates. One of these execution models is named time stepped, where a federate, associated with a simulation component, is considered as a periodical task. In this execution model, data produced by simulation component can only be consumed in the future. This imply a cost in term of logical time delay for every dataflow. In this paper, the model of execution is close to this time stepped execution model, but a federate executes multiple simulation components. This execution model is illustrated in fig. 6, linked to simulation components allocation. This model execution optimizes the use of logical time and allows the definition of task sequence, where logical time delay can be null. This notion of null delays does not exist in real time scheduling or most of the distributed simulation.

V. IMPLEMENTING THE SEA WITH HLA The SEA can be implemented with different distributed simulations. In this paper, we will focus on HLA/CERTI.

The High-Level Architecture (HLA) is a standard from the IEEE, for software architecture [START_REF]IEEE standard for modeling and simulation (M & S) high level architecture (HLA): object model template (OMT) specification[END_REF]. This standard defines methods and a framework to build global simulations comprised of smaller simulations, the federates. The HLA federates communicate through a RunTime Infrastructure (RTI) [START_REF] Gervais | Real-time distributed aircraft simulation through HLA[END_REF], and using publication/subscription mechanisms to exchange data. In this paper, we consider the CERTI implementation [START_REF] Bréholée | Certi: Evolutions of the onera rti prototype[END_REF] for the RTI.

Model instances in the same federate run sequentially. Model instances in different federates run concurrently.

• The models are components of simulation hardcoded or imported into a federate from a library. • The logical processors and local schedulers are the federates.

• The global scheduler is composed of the RTI Gateway (RTIG) and RTI Ambassadors (RTIAs). • The intraprocessor communication is shared memory.

• The interprocessor communication is network communication through RTIG and RTIA. Fig. 7 illustrates the implementation of the execution architecture of simulation with HLA/CERTI, with a partition of 4 models a, b, c and d and three logical processors, considering the use of one computer for the two first logical processors, and one computer for the third one.

The scheduling mechanisms are divided into two levels: The CommonFederate, and the SpecializedFederate inheriting the CommonFederate.

The CommonFederate holds lists of subscribable and publishable objects, bound to a list of attributes, following recommendations from [START_REF] Kuhl | Creating computer simulation systems: an introduction to the high level architecture[END_REF]. The CommonFederate advances its logical time depending on the minor frames through HLA services and executing library models depending on their frequencies. SpecializedFederates, inheriting from CommonFederate, initialise the minor frame and the previous list, depending on the ports in and out linked to extraprocessor communications. The intraprocessor communication is a simple shared memory, instantiated with SpecializedFederate attributes.

Fig. 8 depicts the structural bindings of models in Spe-cializedFederates. Listing 1 depicts how the CommonFederate

VI. SIMULATION CONSTRAINTS

CPS simulation representativity and reproducibility requirements can be translated into constraints, either coming from the simulated systems (frequencies, latencies, . . . ), or the simulation execution. In this section, we will give an insight of the currently identified expressible constraints on CPS simulation scheduling.

In the SEA, interprocessor and intraprocessor communications might have different costs on logical time latencies. Fig. 9 illustrates how different partitions can lead to different logical time latencies. In model C, if data from A and B are compared, then it can lead to a simulation that is not representative of the reality.

Let consider that the two models A and B are sending their logical times to C, that subtracts these logical times. For the We call the constraint of having same latencies on datapaths the coincidence constraints. This constraint is not limited to simple synchronization of transmission. More generally, when a model iteration produces data, processed by other models on different paths, another model might receive the final production on these paths. If the different latencies on different data-paths are representative of the real CPS, and the final component models a system or physical phenomenon tolerating delay, there is no problem, but most of the time this is not the case, and coincidence constraints have to be identified and respected when partitioning and mapping. Such a case is considered in the R-ROSACE example following.

VII. EXAMPLE WITH R-ROSACE A. Introduction to the case study

The ROSACE (Research Open-Source Avionics and Control Engineering) case study covers different steps from the conception to the implementation of a baseline flight controller. Originally, the ROSACE case study started with the flight controller developed in Matlab/SIMULINK, ending with a multi-periodic controller executing on a multi/many-core target [START_REF] Pagetti | The ROSACE case study: from Simulink specification to multi/many-core execution[END_REF]. The case study itself is a longitudinal flight controller, designed to be used as a benchmark and to illustrate the translating of Matlab/SIMULINK specifications to multithreaded code executing on multi/many-cores.

A major challenge of designing ROSACE controller is the need of interactions between control and software engineers. Control engineering and computer science do not consider the same problems in design, as these two disciplines are technically and culturally separated. For instance, computer science does not consider physical system requirements, such as stability, while control engineering ignores important computing limitations, such as tasks schedulability and network resources. This issue is particularly prevalent when designing CPS [START_REF] Henriksson | Cyber-Physical Systems Modeling and Simulation with Modelica[END_REF], endorsing our willingness to base our study on the ROSACE case study.

The ROSACE case study objective is to validate the realtime aspect of the controller implementation. The following properties are taken into account:

P1 Settling time P2 Overshoot P3 Rise time P4 Steady-state error An operational scenario is a set of events that includes the interaction of a system with its environment and its users. The ROSACE case study has multiple operational scenarios. The following multiple operational scenarios are taken into account in the original case study: Case 1 The pilot set a new value to the Vertical Speed (V z ).

V z : 0m.s -1 → 2.5m.s -1 Case 2 The pilot set a new value to the True Airspeed (V a ).

V a : 230m.s -1 → 235m.s -1 Case 3 The pilot wait for t = 50s then set a new Altitude (h).

h : 10000m → 11000m, with V z = -2.5m.s -1 Case 4 The pilot regularly set a new Altitude. h : → 10500m → 11000m → 11500m → 8000m, with V z = -2.5m.s -1 All of them are while in cruise flight, at equilibrium. Case 1 also have the following requirements: The case study models and report is available in [START_REF]R-ROSACE case study[END_REF]. R-ROSACE has been implemented with multiple frameworks, including HLA/CERTI, following the architecture of simulation introduced in this paper, the redundancy of controllers is illustrated in fig. 10. The Flight Control Computers (FCC) correspond to the ROSACE controllers. Three controllers exist in the original case study:

P1 Settling time V z ≤ 10s P2 Overshoot V z ≤ 10% P3 Rise time V z ≤ 6s P4
• Vertical Speed controller.

• True Airspeed controller.

• Altitude controller. We group them in a single component, called FCC, and add a monitoring logic, to use this FCC in command or monitor mode, depending on its usage.

When using multiple FCCs, it must be determined which one will provide commands to the actuators. From the Airbus experience, we know that we have sufficiently information to determine the command, but we have to introduce another component, a wiring model containing switches. This component will simulate the logic of selecting the commands using the relays [START_REF] Bernard | Experiments in model based safety analysis: Flight controls[END_REF].

In R-ROSACE, we will consider a couple of FCCs, each one is composed of a command, and a monitor. We will also add the wiring model between this couple of FCCs, and the actuators.

Figure 11 illustrates the placement of the components in the redundant ROSACE case study. Moreover, the nature of each component is highlighted (continuous or discrete). Different partitions of R-ROSACE has been considered, especially the two boundary ones:

• All the components of the simulation are in a single logical processor, following the order of the dataflows (latencies are minimized).

• Every component has its logical processor (latencies are maximized). Those two boundary partitions show us that there is no problem of logical latencies on R-ROSACE. They are illustrated in figs. 12a, 12b, 13a and 13b, and their predicted executions are illustrated in figs. 14a and14b We also consider partitions that should break the coincidence requirements of the added redundancy. To do so, we isolated the FCCs in a dedicated cluster and manipulated their order during the mapping phase. Figs. 12c, 13c, 13d and13e illustrate the partitions and mappings, and the predicted executions of the FCCs in their cluster are illustrated in figs. [START_REF] Bréholée | Certi: Evolutions of the onera rti prototype[END_REF]. For predicted execution in fig. 15b, the requierment is broken because FCC1A produce a value at t0, consumed by FCC1B at t0 + period(FCC), but the sensors values used by FCC1A and FCC1B came from different sensors model iterations. The data from FCC1A and sensors are not coincident for FCC1B. For predicted execution in fig. 15c, the problem is the same, but with FCC1 and FCC2.

D. Simulation results

Simulation observations are presented for the vertical speed in fig. 16.

P1, P2, P3 and P4 requirements from the R-ROSACE case study (i.e., the avionics world, not the simulation world) are verified for centralized and distributed simulations (figs. 16a and 16b), as well as isolated FCC when they are mapped in order, or partial order (figs. 16c and16d).

We predicted that the execution of mapped FCCs in reverse order, fig. 15c, should not be valid, and the observation of the simulation results in fig. 16e confirm this prediction expressed at simulation scheduling-level.

However, we also predicted that fig. 16d should not be valid, as it does not respect the coincidence constraint, but the case study requirements are still met. This particular test case illustrates that simulated system can back simulation failure. The point is that the FCC1 production is invalid, but FCC2 is, and the redundancy mechanism hides the FCC1 problem. Adding others requirements and observing other metrics could have, a posteriori, help identify the invalidity of the simulation, but in the scope of CPSs simulation, this is not sufficient as it covers the problem a posteriori and it must and is cover a priori with the coincidence constraint.

VIII. CONCLUSION

In [START_REF] Deschamps | Toward a formalism to study the scheduling of Cyber-Physical systems simulations[END_REF], we defined a formalism to analyze the scheduling of CPSs simulations. With this formalism, certain temporal requirements can be verified. Nevertheless, a complete set of constraints could not be directly expressed in the formalism.

In this paper, we detailed the implementation of a case study, R-ROSACE, available on [START_REF]SchedMCore | Easy MultiCore Scheduling Analysis and Simulation[END_REF]. We presented an execution of the case study with HLA/CERTI. We identified in this case study a constraint, expressible on the CPS scheduling during the partition and mapping process. This constraint, the coincidence constraint, is not HLA/CERTI specific, and address every SEA implementation. Other implementation presented in [START_REF] Deschamps | Toward a formalism to study the scheduling of Cyber-Physical systems simulations[END_REF] had the same problem. This paper also illustrates how to identify and express new constraints on CPSs simulations schedulings formalized with SLA and SEA.

Synchronization of dataflow is already treated in the literature, nevertheless, the identification and treatment in the scope of CPS simulation is particular as this problem occurs during simulation components integration (i.e., this is totally related to the simulation execution), and the simulation can be invalid, without visible effects on the results. In future work, we will identify more constraints, with the aim of expressing them in a formalism. Furthermore, we will improve our method of representing the SEA, to take into account concepts that were left behind for now, such as the preemption and overrun. This formalism should be applied in the academic and industrial context to prove that the scheduling of a distributed simulation, is valid by design.

The application of the verification of constraint such as the coincidence constraint will be done with allocation algorithm, automatically searching for the best partition and mapping of an SLA on an SEA, and generating a scheduling of simulation.

Figure 1 :

 1 Figure 1: CPS design.

Figure 2 :

 2 Figure 2: the heterogeneous assembly of components in CPS simulation.

Figure 3 :

 3 Figure 3: Similarity between task and model scheduling.

Figure 4 :

 4 Figure 4: Ideal and more realistic views of dataflows in a CPS.

Figure 5 :

 5 Figure 5: Illustration of the SEA double level of scheduling

Figure 6 :

 6 Figure 6: Illustration of different logical time latencies between components.

Figure 7 :

 7 Figure 7: Illustration of the HLA/CERTI execution architecture.

Figure 8 :

 8 Figure 8: Structure of the binding of models from the library with HLA/CERTI federates.

Figure 9 :

 9 Figure 9: Impact of the partitioning of components on dataflows latencies.

  Steady-state error V z ≤ 5% B. Adding redundancy R-ROSACE is an extension of the open source ROSACE case study, adding redundant controllers [17] [19]. The added redundancy allows us to create multiple datapaths with different latencies.

Figure 10 :

 10 Figure 10: R-ROSACE redundant controllers components, with sensors and wiring as interfaces.

Figure 11 :

 11 Figure 11: The R-ROSACE case study components view

Figure 12 :

 12 Figure 12: Considered partitions for this paper results presentation

Figure 14 :

 14 Figure 14: Predicted executions for this paper results presentation, for simple partitions/mappings

Figure 13 :

 13 Figure 13: Considered mappings for this paper results presentation

Figure 15 :

 15 Figure 15: Predicted executions in LP2 for this paper results presentation, for FCC standalone cases

  (a) Vertical speed evolution, centralized case -one partition for all models, direct order (b) Vertical speed evolution, distributed case -one partition for each model (c) FCC standalone case -one partition for FCCs couples, com executed before mon (d) FCC standalone case -one partition for FCCs couples, one couple com before mon, and one mon before com (e) FCC standalone case -one partition for FCCs couples, mon before com

Figure 16 :

 16 Figure 16: Vertical speed evolution in R-ROSACE, scenario 1: V z c set to 2.5m.s -1

For an interesting discussion about research models and engineering models, see[START_REF] Lee | Plato and the Nerd: The Creative Partnership of Humans and Technology[END_REF].

ACKNOWLEDGEMENT

The work described in this paper is supported through an Industrial Agreement for Research Training -CIFREfinanced by the National Association for Research in Technology (ANRT). This work is also financed and supervised by Airbus, and supervised by the ISAE-SUPAERO, University of Toulouse.


L Duta
email: duta@valahia.ro

F Gh

Filip
email: ffilip@acad.ro

J M Henrioud
email: henrioud@ens2m.fr

APPLYING EQUAL PILES APPROACH TO DISASSEMBLY LINE BALANCING PROBLEM

Keywords: environmental engineering, process control, optimal load flow, time schedule control

Disassembly process decomposes a product into parts or subassemblies. Due to the uncertainties that occur during this process, designing and balancing a disassembly line is a very challenging problem. To deal with the disassembly line balancing problem a new method which relies on the equal piles approach is proposed.

INTRODUCTION

The disassembly process is the main stage in the recycling of manufactured products at the end of their life. Disassembly promotes reuse, recycling, material and energy recovery.

Disassembly is a non-destructive technique: it implies the extraction of the desired components and/or materials. If parts are not reusable after reconditioning, partial or total destructive operations are applied: drilling, cutting, wrenching, and shearing. These techniques are used for material or energy recovery.

Disassembly lines are usually manual and hard work. Products subjected to disassembly have an uncertain structure due to the components conditions. Therefore, designing and optimizing a disassembly system are important problems for the manufacturers whose aim is to gain money and time by using such a system [START_REF] Touzanne | Contribution to a disassembly system design for the end-of-life products[END_REF]. The objective of the Disassembly Line Balancing Problem (DLBP) is to use the resources of the disassembly line as efficiently as possible while meeting the demand.

Very few authors have addressed the problem of Disassembly Line Balancing.

Gungor and Gupta treated for the first time the problem of Simply Disassembly Line Balance (DLBP-S). The formulation of this problem was as follows: a number of n tasks have to be assigned on m machines so as to respect the precedence constraints between the parts of the product [START_REF] Gungor | A Systematic Solution Approach to the Disassembly Line Balancing Problem[END_REF]. In their approach, deterministic operative times are used. Moreover, the disassembly process is considered as the reverse of assembly. The authors didn't take into account the uncertainties of the disassembly process. Recently, the same two authors studied the DLBP in the presence of failures [START_REF] Gungor | A solution approach to the disassembly line balancing problem in the presence of task failures[END_REF]. Disassembly sequences which minimized the idle time were chosen. A failure cost had been assigned to each task with a certain probability. The new approach gives an optimal algorithm for balancing the line in respect of the operative costs. The authors were interested in the architecture of the disassembly line. Their method didn't take into account the end-of-life values of the used components and thus the fact that in real systems destructive operations are sometimes preferred to the un-destructive ones so as to maximize the recuperated value. To this day, these have been the only works that treat the DLBP clearly.

Although the problem of DLBP seems similar to Assembly Line Balancing (ALBP) there are many important differences between assembly and disassembly processes [START_REF] Duta | A Method for Dealing with the Multi-Objective Optimisation Problem of Disassembly Processes[END_REF].

One difference is that in the assembly case operations follow each other considering the physical and functional constraints, while in the disassembly case the precedence between operations is given mainly by the physical constraints, the functional ones being relaxed. Moreover, disassembly is not the reverse of assembly, because some operations cannot be carried out due to the physical degradations of the components and other operations are omitted if they are not profitable. These uncertainties influence the operative times that become stochastic variables.

So, the most difficult problem in a disassembly system is that a disassembly operation can fail any time because of the product or component degradation. In this case we have to choose between applying an alternative destructive disassembly operation (dismantling), and abandoning the disassembly procedure. This decision must be taken in real time because in a used product the components states are not known from the beginning of the process.

In order to balance the operations in the disassembly line we have developed an algorithm based on the Equal Piles Approach.

EQUAL PILES APPROACH

Installing a disassembly system requires large investments and thus needs a long term decision. Depending of the line layout the investor has to take into consideration different objectives. The objective of the simple DLBP is to assign a number of disassembly tasks on a product with individual disassembly times to a fixed number of workstations without violating the existing precedence relationships among the tasks.

In the Equal Piles Approach (EPA) the objective is to equalize the stations loads. This method seeks to assign tasks to a fixed number of stations in such a way that the working time of each station is nearly equal [START_REF] Rekiek | Assembly Line design[END_REF]. Having equal loads on stations means equal working times and therefore equal costs of the work done on each workstation. The simple EPA for the Assembly Line Balancing Problem (ALBP), which does not take precedence constraints into account, is the following: given a set of N objects of various sizes we have to distribute the objects into K 'piles' in such a way that the 'heights' of the piles are as equal as possible [START_REF] Rekiek | Assembly Line design[END_REF].

In the case of the assembly lines, the problem is to equalize stations workloads for a fixed cycle time and number of stations. However, in real industrial systems the EPA must provide a solution which respects all precedence constraints of the product [START_REF] Lambert | Disassembly Sequencing: a survey[END_REF]. If these constraints are violated for a given order of stations along the line, the product has to move against the sense of the line conveyor, visiting at least one station several times. In the case of the disassembly lines we have to equalize the station loads by taking into account the appropriate disassembly task (destructive or not), or even in the situation of process failure. Another difference between the ALBP and DLBP is that in the last case the cycle time is not the ratio between the planning period and the demand of assembled products, but the ratio between the duration of the planning period and the maximum number of products that need to be disassembled to meet a certain demand of components [START_REF] Duta | A Method for Dealing with the Multi-Objective Optimisation Problem of Disassembly Processes[END_REF], [START_REF] Gungor | A Systematic Solution Approach to the Disassembly Line Balancing Problem[END_REF].

In this context, the DLBP can be defined as follows: a number of given disassembly tasks of a product with individual disassembly times must be assigned to a fixed number of workstations in order to satisfy the EPA and the existing precedence relationships among the disassembly tasks, taking into account all the uncertainties that can occur due to the state of the product.

DEALING WITH DLBP

For simplicity we suppose that we have a paced, linear, mono-product disassembly line, and also an infinite supply of products. The workstations are placed on the line in an increasing order of their destructing effect. The disassembly or the dismantling times are assumed to be deterministic and known. The DLBP needs the following input data:

-the desired number of workstation; -the cycle time; -the precedence relationships between disassembly tasks; -the duration of each task; -the possible assignment of the tasks to the workstations With these data and the previous presumptions we can illustrate the data flow for DLBP: if the task j is possibleto be assigned to station i m ij if the task j can be done on station i

 =   1.. , 1.. i n j m = =
To deal with the DLBP formulated before we have to minimize the imbalance between stations by finding the minimum of the function

{ } 2 ( ) 1 n k f t t t cy j k i j tasksW i = - ∑ ∑ = ∈         (1)
For each assignable disassembly sequence k, and then to calculate

( ) { } min f t k k
First, we have to find the matrices of the assignement of the tasks to satisfy the DLBP formulated in 2.

Let

{ }

S s ij = be the researched matrix where

{ 1 0 ' if task j is assigned to workstation i s ij if task j isn t assigned to station i = and 1.. , 1.. i n j m = =
This matrix is subjected to the following constraints:

{ } 0,1 s ij ∈ (2) 1 s ij i = ∑ (3) 0 1 1 n n i s i s ij ik i i ⋅ - ⋅ ≤ ∑ ∑ = = (4) and 1.. , 1.. , 1.. i n j m k m = = =
Constraint (2) is known as the non-divisibility constraint, that does not allow a task to be assigned to more than one station. Constraint (3) is the assignement constraint and it requires that each task is assigned to exactly one station. Constraint ( 4) is the precedence constraint that invokes technological order so that if task k is to done before task j ( k<j ), then k cannot be assigned to a station downstream from task j [START_REF] Nof | Industrial assembly[END_REF].

If we determine the matrices S, we can calculate the sum of the tasks duration on each workstation, which is the term

{ } t j j tasksW i ∑ ∈
from the equation (1).

Then, the objective function f(t) can be minimised.

THE PROPOSED ALGORITHM

To find the matrices S that verify equations ( 2), ( 3) and ( 4) we have used a classic procedure that calculates all the possible assignements of the tasks to the workstation using the notion of cartesian product and the backtracking programming method. Let v be the vector which memorise the valid matrices S. The algorithm is given below:

Step_1

Read the input data m, n, M, cy

Number of stations

The best sequencing of the tasks that satisfy EPA

The possible task for each station

( ) ( ) 2 ( ) 1 n f t q t cy k ik i = - ∑ = end; Step 5 Calculate ( ) { } min f t k k for each assignable disassembly sequence 1..( ) k s d = × Write ( ) f t k , k, S k ; STOP Notes:
1) The cartesian product at the Step_2 is generated using the backtraking programming method; The number of the elements of the cartesian product is ( )

1 1 m n p m ij i j = ∑ ∏ = =
(5)

2) At the Step_3 the procedure Generate_S uses the results of the Step_2:

Generate_S(n, m, i e ) begin for each 1.. i m = for each 1.. j n = 0 s ij = ; for each 1.. i m = 1 , s e i i = ; end; 3) At the Step_4 we see that { } Q q i k k = and ( ) q t i j j tasksW i = ∑ ∈ , 1.. k s d = ×
4) When we give the disassembly sequences by the matrix T we can also take into account the failure of the disassembly process so that the sequence is not completed.

The result of the algorithm is the minimum value of the objective function, the best disassembly sequence k that minimise the imbalance of the line, and the assignement of the tasks to the stations for this sequence in the matrix k S .

EXAMPLES

For the first implementation, we took as reference the disassembly sequences given in [START_REF] Zussman | A Methodology for Modeling an Adaptive Planning of Disassembly Processes[END_REF]) by a Disassembly Petri Net. The order of the tasks for two different disassembly sequences is: We have considered that at the beginning we had two workstations, one that performs disassembly tasks and the other -dismantling tasks. So we must take into consideration some alternative operative times, for example The proposed algorithm was implemented in C++.

Input data used is:

m=5; n=2; 2.5 t cy = ; 1 1 0 0 1 0 1 1 1 1 M =       2 0 1.5 0 1.5 2 1.5 0 1 0 2 1 0 1 0 2 0 1.5 0 1 2 1 0 0 0 2 0 0 0 0 T =                
where the lines three and four corespond to alternative dismantling tasks and the last two lines correspond to incomplete disassembly tasks.

The results of the proposed algorithm are:

k=2; 1 0 0 0 0 2 0 1 1 1 1 S =       and ( ) 0.25 2 f t =
We have reached the conclusion that the best disassembly sequence that minimizes the imbalance of the line is the second one. The sequencing of tasks is , , 1 2 4 task task task with the following assignments: task 1 to W 1 , task 2 and task 4 at workstation W 2 . We notice that the line is well balanced, the value of the objective function being under 1.

For the second example we validated our algorithm in the case of a radio disassembly [START_REF] Salomonski | On-line Predictive Model for Disassembly Process Planning Adaptation[END_REF]. The disassembly sequences are given in a Disassembly Petri Net [START_REF] Moore | Disassembly Process Planning Using Petri Nets[END_REF].

The input data is given below: m=8; n=4; 1 t cy = 1 1 1 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1

M =            
and 0.12 0.07 0.07 0.12 0.95 0.75 0.75 0.95 0.15 0.07 0.07 0.12 0.95 0.75 0.75 0.95 0.15 0.07 0.07 0.15 0.95 0.75 0.75 0.95 0.15 0.07 0.07 0.12 0.95 0.9 0.75 0.95

T =            
The results are:

( )

3; 0.57 3 k f t = =
1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 3 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1

S =            
In this case the best disassembly sequence that gives a good balance of the line is the 3 rd one, that is given in the matrix T. The order of the tasks is where the first and the fourth tasks are dismantling ones. The assignement is: task 1,1 , task 2 , task 3 , task 4,1 to W 1 , task 5 to W 2 , task 6 and task 7 to W 3 and task 8 to W 4 .

DISASSEMBLY SYSTEM CONTROL

The control of disassembly process involves two essential decision variables: disassembly level and disassembly mode: clean or destructive. A third decision variable may be added: the task to station assignment.

When we speak of controlling a disassembly process we must take into consideration the use in real time of the Decision Support Systems (DSS). Usually, DSS in real time are used in "crisis" situations like: the stop of the production flow, the machines out of order, appearance of unpredictable situations, value changing of one or more production parameters [START_REF] Filip | Computer Aided Decision[END_REF]. The DSS must be in permanent dialog with the control system. This increases the reactivity of the control system at the appearance of difficult situations. In fact, there are situations in which the decision must be taken very quickly so as to give optimal command to the process.

The same situation can occur in a disassembly process: a disassembly operation cannot be carried out due to the bad state of the part or of the product itself. A decision must be taken so that the disassembly process can continue without failures.

In the case of manual disassembly, the perturbation is analyzed by a human operator. In the case of an automatic process, specialized detection and analysis tools are needed. Moreover, in the case of disassembly lines the control system has to decide the flow of tasks on workstations. This means that the systems control has to make a good balancing of the disassembly line. In this case a DSS has to be integrated in the architecture of the system control. A Data Base and a Knowledge Base are created with all the characteristics of the product (DB+KB).

This information is sent to the planner that analyzes the data together with the given manufactured problem. The result of the planner is a model of the product or of the process itself, model that can be next simulated on a computer. The integrated DSS gives the best decision-solution of the manufacturing problem in respect to the chosen criteria. It also generates some data files that are used by the control system to provide the necessary command to the process. The reactivity loop is closed by the visual information analysis system that acquires information in real time from the process and sends it on the serial bus to be analysed by the DSS. So the dialogue between the two systems is permanent .

In the Figure 1, the architecture for controlling a disassembly process is proposed [START_REF] Duta | Automatic Disassembly Systems Control[END_REF].

Fig. 2. Integrating DSS in the process control

We particulized this architecture in the case of the disassembly systems. As a planner we used the software LEGA, entirely conceived in the Automatic Laboratory of Besançon, France, [START_REF] Addouche | Integration of Reassembly Tasks in Disassembly Process Planning[END_REF] and the DSS is the software that integrates the program that assures a good balance of the line. LEGA gives all the possible disassembly sequences of the product using modeling by Petri Nets. DSS analyzes these sequences and it gives the best decision for disassembling the product and the flow of products on the line. This is a good feature of the system because manufactures are interested in reducing waste and difficulties in disassembling endof-life products and reducing time in revalorization of the subassemblies [START_REF] Addouche | Linear Programming Model to Find the Optimal Disassembly Sequence[END_REF]. The disassembly planner gives the sequence of the components that must be separated to achieve the target. It can be computed for the total disassembly of the product or for its partial disassembly [START_REF] Wiendahl | A General Approach to Disassembly Planning and Control[END_REF]. Output data from LEGA (given in the output files) is the input data for DSS. The Decision Support System (DSS) integrates the model and performs the simulation. As a result, tasks are assigned to workstations. The algorithm presented in paragraph 4 is executed and the Decision System provides the best disassembly sequence that minimizes the imbalance of the line. At a given moment, this is an off-line solution.

DSS Planner

It is the role of the control system to use this information to change the states of the variables that control the movements of the line and robots. The control system merges the information from the artificial vision system (linked to the Ethernet Network) with that contained in the database for each component or subassembly. There is an information feedback that allows the adjustment of the model while the product is disassembled, since there are components that can be visible only after removing other ones. The values obtained as a result of the proposed algorithm are saved in files. The control software uses these files to change the variables in the system. A good balance of the line is assured.

The software is entirely written in the C++ language.

The system needs a host computer that is responsible for the coordination of the control task, a personal computer for planning and simulation and an artificial vision system with mobile cameras.

CONCLUSIONS

The validity of the algorithm was proved in two situations: one in which the number of stations is small and the value of the time cycle is rather high, and the other when the number of stations is bigger but the cycle time cy t is smaller. By increasing the number of stations one could observe that the value of the objective function f (t) rises, so the line is less balanced. Indeed, f(t) is a cost function. The bigger the number of stations the smaller the number of tasks by station, so the line cost increases and the balancing becomes more complicated. There is a similar situation in the case of the disassembly failure: the imbalance is greater because of the incomplete sequences. Thus, one has to change the design of the line (decreasing the number of workstations) or, better, to choose another disassembly sequence. A new system control architecture that provides a normal flow of the product on the disassembly line was proposed. A Decision Support System (DSS) was integrated in the control architecture. The DSS analyzes the model and performs the simulation. As a result a good balance of the line is given.

However, the proposed method has its limitations. The complexity of the algorithm is exponential and is given mainly by the structure of the line (the number of workstations) and the number of disassembly tasks. In the objective function f(t) we did not take into account the profit that can be obtained by the valorisation of the disassembled components. Future work will focus on the problem of maximising this income while minimising the cost of the disassembly line using multi-criteria optimisation methods.

Fig. 1 .

 1 Fig. 1. Data flow for DLBP Used notation: m number of tasks n number of stations d number of possible disassembly sequences cy t cycle time j t the operative time of task j T = { } k t j k=1..d and j=1..m the matrix of the operative times for each disassembly sequence k { } M m ij = the matrix of possible assignement of the tasks, where


Didier Schwab
email: didier.schwab@univ-grenoble-alpes.fr

Amela Fejza
email: amela.fejza@grenoble-inp.org

Loïc Vial
email: loic.vial@univ-grenoble-alpes.fr

Yann Robert
email: yann.robert@anantaplex.fr

The GazePlay Project: Open and Free Eye-trackers Games and a Community for People with Multiple Disabilities

Keywords: Eye-trackers, Games, Serious Games, Children with Multiple Disabilities, Augmentative and Alternative Communication, Human-Computer Interaction, Eye-based Interaction

In order to develop and enhance an augmentative and alternative communication (AAC), gaze is often considered as one of the most natural way and one of the easiest to set up in order to support individuals with multiple disabilities to interact with their environment. For children who start naturally from scratch, who have in addition such difficulties, it is a strong challenge even to acquire or to support the required basic knowledge. Games are often considered as a good way to learn. Games designed for eye-trackers, i.e. electronic devices able to compute the position of the gaze, allow children to discover the power of their eyes and the consequences of the actions triggered by their gazes. Video games can be a good way to improve basic requirements as gaze fixation and gaze pursuit as well as conventions like rewards or dwell interactions often used in AAC tools. In this article, we present the GazePlay project which main contribution is a free and open-source software which gathers several mini-games playable with any eye-trackers including low cost ones.

Introduction

In order to develop and enhance an augmentative and alternative communication (AAC), gaze is often considered as being one of the most natural way and one of the easiest to set up in order to support individuals with multiple disabilities to interact with their environment. Of course, for children who start naturally from scratch, who have in addition such difficulties, it is a strong challenge even to acquire or to support the required basic knowledge. They have to learn the power of their eyes, the consequences of the actions triggered by their gazes, they have also to improve their extraocular muscles, etc.

Institute of Engineering Univ. Grenoble Alpes

Games are often considered as a good way to learn. In the case of eye-tracking, video games could be a good way to improve basic requirements as gaze fixation and gaze pursuit as well as conventions like rewards or dwell interactions often used in AAC tools.

In this article, we present the GazePlay project which main contributions are -GazePlay3 a free and open-source software which gathers several mini-games playable with any eye-trackers including low cost ones. It permits people to access such games at a price which decreases from 2 000-3 000e to 100-160e excluding computer price. -TobiiStreamEngineForJava library 4 , a Java open library which links C++ library from Tobii to Java. With its help, is possible to develop softwares able to interact with Tobii's low-cost eye-trackers (Tobii EyeX, Tobii 4C). -GazePlay github5 a public repository hosted by GitHub which helps us to manage GazePlay development. At the end of March 2018, ten people directly contributed to the code and dozens on ideas (including therapists and parents).

Eye, Gaze and Eye-trackers

Eye is a sense organ that allows vision. It allows humans to see images in 3 dimensions and with colors. Eyes make specific motions [START_REF] Yarbus | Eye Movements and Vision[END_REF][10]:

-Saccade happens when the eyes move from one point of interest to another.

-Pursuit happens when the eyes follow a moving target.

-Fixation happens when the eyes stop scanning the scene, and the vision is kept in one place so it can take detailed information about the object or the scene it is focused on. -Blinking is a rapid closing then opening of the eyelids. When it occurs spontaneously, it protects the eye by moistening it. When it occurs voluntary, blinking can be used to reestablish a basic communication.

Naked-eye observations go back to the French ophthalmologist Louis Émile Javal (1839-1907), who noticed for the first time that readers eyes do not skim fluently through the text while reading, but make quick movements mixed with short pauses where the eye gets fixated [START_REF] Lupu | A survey of eye tracking methods and applications[END_REF]. The very first eye-tracker was created in 1908, again for an experiment about reading. At that time, eye-tracking was really intrusive and uncomfortable for the readers because they had to wear a type of contact lens with a small opening for the pupil. This lens was attached to a pointer which changed its position with the movement of the eye.

Nowadays, eye-trackers are mainly infrared cameras which provide raw coordinates from which it is possible to estimate fixation, saccades, poursuites and/or blinking [8] [4]. Several companies build eye-trackers, for marketing, virtual and augmented reality or to evaluate driver vigilance [START_REF] Kar | A review and analysis of eye-gaze estimation systems, algorithms and performance evaluation methods in consumer platforms[END_REF]. Eye-based interaction has been used for disabled people since the early 1980's [START_REF] Friedman | The eyetracker communication system[END_REF] but main work about interaction is [START_REF] Jacob | What you look at is what you get: Eye movement-based interaction techniques[END_REF] where several solutions including dwell interaction which is often used to select in AAC softwares are discussed (see section 3.1).

Until recently, eye-tracker were really expensive devices and were not affordable by the majority of families of disabled people. For instance, in France, the cost of a basic eye-tracker for disabled people is over 1200e in the beginning of 2018 (it was the double one year before).

In 2013, the Eye-Tribe company was the first to extremely lower the cost by creating cheap and more affordable eye-trackers with an elegant Java API and compatible with both Windows and OS X. Tobii, the most important firm to sell eye-trackers released their EyeX (2014, 100e) followed by the Tobii 4C (2016, 160e) and their C++ library. While the Eye-tribe was sold to Facebook for its Oculus division and is no longer developped, Tobii works a lot on their low-cost eye-trackers and their associated tools (multiple users, gaze trace, etc.). These three eye-trackers can be used with GazePlay. We integrate directly eye-tribe library while our team has developed a Java Native Interface to build a java library, TobiiStreamEngineForJava which permits to use easily the Tobii EyeX and the Tobii 4C with Java.

GazePlay

We present in the following GazePlay 1.3, the version of GazePlay we released at the end of March, 2018. GazePlay is a free and open-source software which gathers 22 mini-games playable with an eye-tracker. It is compatible with all eye-trackers which are able to control the mouse cursor, with Tobii EyeX and Tobii 4C on Windows and the Eye Tribe Tracker on Windows or MacOs X. To help motivating the players, it is very easy to modify default images of the game. One player would prefer to play with Mickey Mouse while another would like to play with Princess Sofia, with his family or therapist. Another way to help motivating the players is to give them a reward (a big friendly smiley and applauses). Interface and games are fully translated in French, English and German.

Games in GazePlay

GazePlay 1.3, gathers 17 playable games 6 . For each one, we aim to develop one or several skills for the children. We can consider that three kinds of skills are developed in GazePlay: action-reaction, selection, memorization skills. Action-Reaction Skill The purpose of these games is to teach the children that a gaze can have direct consequences. For instance, in the creampie game, the user throws a custard pie on the target when gaze looks at it (see figure 3) ; in Blocks, a big image is hidden by colored blocks. The player looks at a block to destroy it. When all blocks have disappeared, a reward is shown. In the Ninja game, the target explodes when the player looks at it.

Selection Skill Selection with eye-tracker is not as easy as it is with a mouse. Blinking is both not easy to capture with an eye-tracker and often very difficult to perform for a child with multiple disabilities. In AAC programs, an usual way to select an element (photo, image, pictogram, etc.) is to keep the gaze on this element. It is called, a dwell interaction [START_REF] Jacob | What you look at is what you get: Eye movement-based interaction techniques[END_REF]. A feedback is given as a circular progress bar. When it is completed after a time that can be configured, the element is selected [START_REF] Nguyen | Gaze-Based Interaction: Evaluation of Progressive Feedback[END_REF]. In Magic Cards several cards are displayed. One of the card hides an image. When the player stares at one card, it is turned. If (s)he finds the image, a reward is given to the player. Other games like Memory and Where is it? aim at training the selection skill.

Memorization Skill The purpose of these games is to work on the short-term memory like in memory which has the same rules as the ones of the classic game. Several pairs of cards from 2 to 6 (according to the child/helper choice), face down. Then the player uses a dwell interaction (see previous section) to turn over 2 cards. If both cards are the same, they disappear, otherwise they turn back over after a few seconds to allow the player to remember them. When all cards have been matched, the reward is given.

In other games, we aim at working on long-term memory. In the game Where is the animal?, a sentence is pronounced and written to indicate to the player which animal to find (horse, dog, crocodile,...) and then several photos of animals are shown (from 4 to 9 according to the child/helper choice). Player selects photos until (s)he finds the correct one. The same game is proposed with colors. An additional one is completely configurable ie. parents/therapists can build their own games with their own photos. The sentence can be completed with pictograms for instance to teach them to the children (see figure 4). This game and the use of pictograms was inspired by the community (see section 4).

Analysis

When a game is stopped by the helper, statistics are displayed and saved automatically. They include charts which present depending on the game, total active playtime, actual playtime, durations, reaction length, standard deviation,etc. A heatmap also shows gaze position on the screen. With these statistics, helpers get objective information to evaluate motivation and/or evolution of children.

The Community as the Future of GazePlay

The project is open source under a GNU General Public License v3.0 7 . Anyone can modify it as long as (s)he distributes hi(s)her code. It remains possible to sell customized version of GazePlay or services using GazePlay including therapies or tutorials.

The GazePlay project started with the first author who is both an associate professor in informatics and the father of a girl with multiple disabilities. Sharing experience with other parents especially the ones who already own eye-trackers and games for their children and with therapists [START_REF] Schwab | Gazeplay : Creation of a community to help the development of a free and open-source plateform to make eye-tracker video games accessible to everyone[END_REF], he worked with postgraduate students (second and third authors) to release first versions of GazePlay.

The code is hosted on GitHub. The repository permits to share code, information for developers, issues (enhancements, bugs, milestones, etc) but also to find interesting projects. Due to his goal, some people (fourth author for instance) from the open source community helped us especially on the software engineering side and permited to increase our efficiency. Similarly, we get regular feedback from many therapists who used GazePlay with children.

GazePlay was downloaded almost 800 times since its first release. We really hope that such a project can inspire others to build new projects related to people with special needs.

Fig. 1 .

 1 Fig. 1. Two of the eye-trackers which permit to play with GazePlay: the Eye Tribe upper side, the Tobii 4C bottom side

Fig. 2 .

 2 Fig. 2. Screenshot of the main menu of GazePlay development version on the 25th of March, 2018. They are currently 22 games (17 fully playable).

Fig. 3 .

 3 Fig. 3. A child who plays the creampie game with an Eye Tribe tracker.

Fig. 4 .

 4 Fig. 4. Screenshot of the game where is it?, the question is asked associated to a pictogram from Makaton vocabulary [2].

Fig. 5 .

 5 Fig. 5. Screenshot of statistics for an action-reaction focused game.

https://gazeplay.net

https://github.com/coylz/TobiiStreamEngineForJava

https://github.com/schwabdidier/GazePlay

For a complete description of games see https://gazeplayeng.wordpress.com/games/

https://www.gnu.org/licenses/gpl-3.0.en.html