Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Université Larbi Ben M'hidi Oum El Bouaghi

Faculté des sciences exactes et sciences de la nature et de la vie

Département De Mathématiques Et D’informatique

Mémoire de fin d'étude en vue de l'obtention du diplôme de Master

en Informatique

Spécialité :Architecture distribué

Thème :

L’utilisation de N-Version de programmation pour la prise en charge des fautes

dans un environnement IoT:

Présenté par: Hadjadj Walid

Devant le jury :

Mme Zaiter Meriem Encadreur/rapporteur

Mr MARIR Toufik Examinateur
Mme KOUAH Sofia Examinateur

Soutenu le : 13/06/2018

2017-2018
1
 Résumé
La technologie de l'Internet des Objets (IoT) a attiré beaucoup d'attention ces
dernières années en particulier dans le domaine médical. La sûreté de fonctionnement
de ce système est une nécessité. Notre objectif dans ce mémoire est de contribuer dans
ce domaine et spécialement dans la tolérance aux fautes. Cette dernière, est l’un des
grands défis dans IoT. Ce document d'étude présente l’une des techniques de la
tolérance aux fautes qui est la n-version de programmation qui consiste à créer des
alternatives de réponse en cas de détection d’une faute. Notre système médical est
contrôlé par un SMA et des codes alternatifs seront intégrés dans le comportement des
agents.

Mots clés : système médical, IoT, N-Version de programmation, faute,

agent, la tolérance aux fautes.

1
 Abstract
The technology of the Internet of Things (IoT) has attracted a lot of attention in
recent years especially in the medical field. The dependability of this system is a
necessity. Our goal in this dissertation is to contribute in this field and especially in fault
tolerance. The latter, is one of the big challenges in IoT. This study document presents
one of the techniques of fault tolerance, which is the n-version programming, which
consists in creating alternatives of response in case of detection of a fault. Our medical
system is controlled by a Multi Agent System and alternative codes will be incorporated
into the behavior of the agents.

Key words: medical system, IoT, N-Version programming, fault, agent,

fault tolerance.

2
 ‫ملخص‬
‫تمكنت تكنولوجيا إنترنت األشياء من جذب الكثير من االهتمام في السنوات األخيرة وخاصة في المجال‬
‫الطبي‪.‬و اصبح اعتمادية هذا النظام هو ضرورة‪ .‬هدفنا في هذه المذكرة هو المساهمة في هذا المجال وخاصة في‬
‫التسامح مع الخطأ‪ .‬هذا األخير‪ ،‬هو واحد من أكبر التحديات في إنترنت األشياء‪ .‬تقدم هذه الدراسة واحدة من تقنيات‬
‫التسامح مع الخطأ وهي ن‪-‬نسخة من البرمجة التي تتمثل في إنشاء بدائل لالستجابة في حالة الكشف عن خطأ‪ .‬يتم‬
‫التحكم في نظامنا الطبي بواسطة نضام متعدد الوكالء وسيتم دمج النسخ البديلة في سلوك الوكالء‪.‬‬

‫النظام الطبي ‪ ،‬إنترنت األشياء ‪ ،‬ن‪-‬نسخة من برمجة ‪ ،‬الخطأ ‪ ،‬الوكيل‬ ‫الكلمات المفتاحية ‪:‬‬
‫‪ ،‬التسامح مع الخطأ‪.‬‬

‫‪3‬‬
 Remerciements

En préambule à ce mémoire je remercie ALLAH

qui nous aide et nous donne la patience et le courage durant ces
langues années d’étude.
Je teins à remercier sincèrement madame Zaiter, qui, en
tant que encadreur de mémoire, s’est toujours été à l’écoute et très
disponible tout au long de la réalisation de ce mémoire, ainsi pour
l’inspiration, l’aide et le temps qu’elle a consacré pour mener à
bien ce mémoire.
Mes remerciements sont aussi adressés aux membres de
jury qui ont accepté de juger ce travail.
Je n’oublie pas de remercier ma famille pour leur
contribution, leur soutien et leur patience.
Enfin, j’adresse mes plus sincères remerciements à tous nos
proches et amis, qui nous ont toujours m’encouragés au cours de
la réalisation de ce mémoire.
Merci à tous et à toutes.

4
Table des matières

Résumé ............................................................................................................................. 1

Introduction générale ................................................................................................... 10

Chapitre I : L’internet des objets (IOT) ..................................................................... 11

1. Introduction ............................................................................................... 11

2. La Définition ............................................................................................. 11

3. La Motivation ........................................................................................... 12

4. Le Domaine D’Application ...................................................................... 13

4.1 Les Villes Intelligentes........................................................................................ 13

4.2 Le Smart Grid : ................................................................................................... 14

4.3 Les Appareils Intelligents : ................................................................................. 15

4.4 Les Maisons et Les Bâtiments Intelligents ......................................................... 16

4.5 Le Système De Santé Electronique ..................................................................... 17

4.6 Le Transport et La Mobilité Intelligent ............................................................... 18

4.7 Les Usines et La Fabrication Intelligente ........................................................... 19

4.8 La Surveillance à Distance Des Patients ............................................................. 20

5. Les Composants De L’IOT ....................................................................... 21

6. Les Défis de l’IOT .................................................................................... 23

6.1 La Découverte Automatique ................................................................................ 23

6.2 L’Interopérabilité ................................................................................................. 23

6.3 La Sécurité et La Confidentialité ......................................................................... 23

6.4 La Tolérance Aux Pannes : .................................................................................. 24

5
 6.5 L’Auto-Organisation ........................................................................................... 24

7. Conclusion ................................................................................................ 24

Chapitre 2 : La Tolérance au fautes dans L’internet des objets (IOT) ................... 25

1. Introduction ............................................................................................... 25

2. Définitions ................................................................................................ 25

2.1 La Sûreté De Fonctionnement............................................................................. 25

2.2 Les Attributs De La Sureté De Fonctionnement ................................................. 25

2.3 Les Moyens D’Assurer La Sureté De Fonctionnement ...................................... 26

2.4 La Tolérance Aux Fautes .................................................................................... 26

2.5 La Détection d’Erreur ......................................................................................... 27

2.6 Le Rétablissement Du Système........................................................................... 27

3. Les Modes De Défaillance et Les Hypothèses ......................................... 28

4. La Tolérance Aux Fautes et l’IoT Médical ............................................... 29

5. Conclusion ................................................................................................ 30

Chapitre 3 : La Conception De La Proposition ......................................................... 31

.1 Introduction ............................................................................................... 31

2. Le Contexte et l’Objectif .......................................................................... 31

3. Le Détaille De La Proposition .................................................................. 31

3.1 L’Architecture du système de contrôle : ............................................................. 32

4. La Conception Détaillée De Notre Proposition ........................................ 33

4.1 Brève description d'AUML ................................................................................. 33

4.2 La Représentation De La Vue Statique Des Agents Contrôleurs ................. 34

4.3 La Représentation De La Vue Dynamique Des Agents Contrôleurs .................. 35

5. Conclusion ................................................................................................ 45

6
Chapitre 4 : L’Implémentation De La Proposition ................................................... 46

.1 Introduction ............................................................................................... 46

2. La Représentation Des Technologies et Les Langages ............................ 46

2.1 phpMyAdmin ...................................................................................................... 46

2.2 Eclipse………………………………………………………………………...46

2.3 Jade…………...................................................................................................... 47

3. La Description De La Simulation ............................................................. 47

3.1 L’Authentification ............................................................................................... 48

3.2 L’Ajoute D’un Patient ......................................................................................... 50

3.3 L’Affichage D’état Du Système ......................................................................... 51

3.4 L’Ajoute D’un Composant.................................................................................. 53

3.5 Le Déclenchement D’une Faute .......................................................................... 55

3.6 L’Affichage Des Statistiques .............................................................................. 57

4. Conclusion ................................................................................................ 61

Conclusion général ........................................................................................................ 62

Bibliographie ................................................................................................................. 63

7
 Table des figures
Figure 1 : une figure qui représente les constituants d’une ville intelligente ...................... 14

Figure 2 : une figure qui représente les constituants d’une smart grid ................................ 15

Figure 3 : une figure qui représente des appareilles intelligent ........................................... 16

Figure 4 : une figure qui représente un bâtiment intelligent ............................................... 17

Figure 5 : figure qui représente un système de santé électronique ...................................... 18

Figure 6 : figure sui représente les aspects de transport intelligent ..................................... 19

Figure 7 : figure qui représente un schéma de l’industrie 4.0 ............................................. 20

Figure 8 :figure qui représente le mécanisme de la surveillance distants des patients ........ 21

Figure 9 : l’architecture du mechanisme du contrôle .......................................................... 32

Figure 10 : une figure qui représente le diagramme de class .............................................. 34

Figure 12 : Diagramme de séquence «ajouter composant ................................................... 36

Figure 13 : Diagramme de séquence «afficher statistique »................................................ 38

Figure 14 : Diagramme de séquence «Injecter faute » ........................................................ 40

Figure 11 : Diagramme de séquence « afficher l’état de système » .................................... 42

Figure 17 : Diagramme d’activité « injecter faute « ............................................................ 43

Figure 15 : Diagramme d’activité « afficher l’état de système ........................................... 44

Figure 16 : Diagramme d’activité « ajouter composant « ................................................... 45

Figure 18 : figure qui représente le logo de phpmyadmin .................................................. 46

Figure 19 : figure qui représente le logo d’eclipse .............................................................. 47

Figure 20 : figure qui représente le logo de JADE .............................................................. 47

Figure 21 : présentation de l’Interface De l’Authentification ............................................. 48

Figure 22 : présentation de interface principale du simulateur .......................................... 49

Figure 23 : figure qui représente l’interface jade avec des agents crées ............................. 49

8
 Figure 24 : figure qui représente la base de données ........................................................... 50

Figure 25 : figure qui représente un exemple d’ajouter patient ........................................... 50

Figure 26 : la représentation de l’état de système après l’ajout d’un patient ...................... 51

Figure 27 : la maj de la base de données après l’ajout d’un patient .................................... 51

Figure 28 : représentation d’échange des valeurs entre les agents en utilisant l’agent
Sniffer. ............................................................................................................................ 52

Figure 29 : une figure qui représente l’état de système ....................................................... 52

Figure 30 : 1ere formulaire d’ajout d’un composant ........................................................... 53

Figure 31 : 2eme formulaire d’ajoute d’un composant ....................................................... 54

Figure 32 : : la création d’un nouveau agent ...................................................................... 54

Figure 33 : l’état de système avec l’ajout de nouveau composant ...................................... 55

Figure 34 : une fenêtre demande le choix du type de faute ................................................. 55

Figure 35 : interface jade qui montre la création du virus. .................................................. 56

Figure 36 : figure qui représente le clignotement du panneau spo ...................................... 56

Figure 37 : figure qui représente le formulaire de d’affichage les statistique ..................... 57

Figure 38 : un exemple des résultats obtenus ...................................................................... 58

Figure 39 :figure qui représente exemple des résultats dans un moment précis (un état
d’alerte) ........................................................................................................................... 59

Figure 40 :figure qui représente l’alerte au niveau de ECG et la valeur de BC calculée .... 60

Figure 41 :figure qui représente les valeur de spo envoyé sans l’utilisation de n-version de
programmation ................................................................................................................ 60

Figure 42 : une figure qui représente les valeurs envoyées au centre de santé médical avec
utilisation de la n-version de programmation ................................................................. 61
.

9
 Introduction générale
Le développement croissant dans le domaine de l’informatique a encouragé
l’intégration d’une variété de dispositifs sophistiqués dans les maisons. Ces dispositifs
communiquent entre eux pour aider les utilisateurs dans des situations particulières et
selon leurs besoins comme dans la sécurité, le confort, et même la santé. Les
dispositifs forme un environnement de connexion d’objets cet environnement est mis
en œuvre par des systèmes d’objets connectés connue sous le nom internet des objets
(IoT). Ces systèmes sont de plus en plus utilisés surtout dans le cas des personnes à
autonomie réduite. Dans le domaine médical l’IoT peut faciliter la collection des
informations en temps réel en utilisant des capteurs, pour identifier l’état dans lequel
se trouve le patient surveillé telles que sa position, ses signes vitaux, et toutes autres
informations pertinentes. Ces systèmes ont une forte contrainte de sûreté car une faute
propagée dans le système engendre des conséquences catastrophiques sur la vie
humaine.

Notre objectif est l’exploitation de la corrélation entre les signes physiologiques

pour créer des alternatives de réponse et tolérer l’existence des fautes. Cette tolérance
assure par conséquence une disponibilité continue des fonctionnalités requises par le
système. Notre proposition rentre dans le cadre de la réplication de code qui est une
forme de la N-version de programmation.

Ce mémoire est composé de 4 chapitres : le premier chapitre est une survole sur
les caractéristiques des environnements (IoT) médicaux. Tandis que le second chapitre
présente la tolérance aux fautes dans l’internet des objets et les systèmes médicaux, et
par le troisième chapitre on va présenter la conception détaillée de notre système. Le
dernier chapitre est consacrée pour exposer les différentes outils servant à la
l’expérimentation qui permet de voir l’efficacité de notre proposition. Finalement, une
conclusion générale résume l’ensemble de notre travail.

10
 Chapitre I : L’internet Des Objets
(IOT)

1. Introduction
Au cours des dernières années, nous avons été témoins de l'excitation de
l'Internet des objets, également connu sous le nom d'IoT. Il est possible de remarquer
l'engagement des entreprises et des universités à la recherche de solutions pour faire le
concept de «l'Internet des objets» deviennent réelles.

De nos jours, nous vivons entourés de dispositifs électroniques, à la maison, au

travail ou dans d’autres environnements, même à l'intérieur du corps des gens, (André
Pedroza, 2016)

En santé, nous trouvons un domaine ouvert et motivé dans la recherche de

solutions technologiques pour une meilleure efficacité et un gain d’argent. Cet
avantage peut accroitre l’accessibilité à ce domaine par une plus grande population.

Dans ce contexte, le cyber santé est introduit. Il est défini comme l'utilisation
des dispositifs électroniques et d'autres technologies pour aider à la pratique des soins
de santé. Cela comprend les prescriptions médicales et la surveillance à distance des
patients.

Dans ce chapitre, nous présentons les principaux concepts de Internet of

Things (IoT), entre autre les smarts dispositifs, capteurs et l’Internet lui-même. Nous
présentons également un tour d’horizon sur l’état l’art d’Internet of Things (IoT) et ses
domaines d’application.

2. La Définition
Le terme d’Internet des Objets (IdO)1 ne fait pas encore consensus sur sa
définition, ce qui s’explique par la jeunesse de ce concept en pleine mutation. Il existe
ainsi autant de définitions que d’entités impliquées dans la réflexion, le développement
ou la normalisation de ce nouveau paradigme.

1
En anglais Internet Of Things,IoT .

11
 Le groupe de travail Internet of Things Global Standards Initiative (IoT-GSI),
piloté par l’International Télécommunication Union (ITU), considère l’IoT comme «
une infrastructure mondiale au service de la société de l’information » permettant «
d’offrir des services évolués en interconnectant des objets (physiques et virtuels) grâce
à l’interopérabilité de technologies de l’information et de la communication existantes
ou en évolution.

De son côté, l’IEEE définit l’IoT comme un « réseau d’éléments chacun muni de
capteurs qui sont connectés à Internet ».

L’IoT-GSI définit également un objet connecté comme un équipement possédant

les sept attributs suivants :

 Capteurs

 Connectivité à Internet

 Processeurs

 Efficacité énergétique

 Coût optimisé

 Fiabilité

 Sécurité (Christophe Baland, 2017)

3. La Motivation
Actuellement, le développement des applications IoT a été intégré dans de
nombreuses tâches dans notre vie quotidienne.

La santé peut coûter cher, que les soins soient prodigués par un système public
ou privé. La réduction des coûts est donc un mouvement commun à l'ensemble du
secteur.

Dans ce cadre, les objets connectés peuvent servir à réduire certains éléments de
dépenses pour les remplacer par d'autres .L'apport de l'Internet des objets peut ainsi
permettre de :

12
  favoriser l'hospitalisation à domicile,

 réduire les erreurs médicales,

 optimiser la consommation de médicaments ou encore leur prise régulière (via

des piluliers connectés) et

 encourager la prévention de certaines maladies.

Le champ d’utilisation est large et pourraient permettre de générer des gains de

temps2.

4. Le Domaine D’Application

L'internet offre de nombreuses applications à ses utilisateurs. Parmi ces

applications nous citons :

4.1 Les Villes Intelligentes

Beaucoup de grandes villes ont été soutenues par des projets intelligents, comme
Séoul, New York, Tokyo, Shanghai, Singapour, Amsterdam et Dubaï. Les villes
intelligentes (voir Figure.1) peuvent encore être considérées comme des villes de
l'avenir et la vie intelligente, et par le taux d'innovation de la création de villes
intelligentes d'aujourd'hui, il sera devenu très faisable pour entrer la technologie IoT
dans le développement des villes.

La demande exige une planification minutieuse à chaque étape, avec l'appui de

l'accord des gouvernements, citoyens à mettre en œuvre la technologie d’Internet des
objets dans tous les aspects. Par l'IoT, les villes peuvent être améliorées à plusieurs
niveaux, en améliorant les infrastructures, en améliorant les transports….

2
http://www.clubic.com/pro/actualite-e-business/actualite-791194-internet-objets-at-kearney-
gagnants-perdant-iot.html consulté le 14/02/2018

13
 Figure 1 : une figure qui représente les constituants d’une ville intelligente

4.2 Le Smart Grid :

L’un des domaines d’application de l’IoT est le secteur de la distribution

d’énergie intelligente, dit « Smart Grid » (voir figure 2). En France, ERDF est très
actif dans le développement de ce domaine, où un besoin clair en récupération
d’information à différents points du réseau électrique est devenue nécessaire pour une

14
 meilleure intégration des différentes sources d’énergies et une meilleure gestion de la
distribution jusqu’aux utilisateurs finaux3.

Figure 2 : une figure qui représente les constituants d’une smart grid

4.3 Les Appareils Intelligents :

Des appareils intelligents (voir figure 3) dans les soins de santé sont utilisés pour
stocker et gérer les paramètres de soins clés et pour gérer les données sur les maladies
capturées. Ils sont principalement déployés pour fournir des solutions de
conditionnement physique en suivant les activités ciblées et des dispositifs de
diagnostic utilisés pour stocker des données de dispositifs. Principalement, ils sont
utilisés comme des solutions de fitness pour suivi des activités du patient et des
appareils de diagnostic intelligents tels que les dispositifs de tension matérielle, les

3
https://www.fun-mooc.fr/c4x/MinesTelecom/04013/asset/S4-5_-Objets-communicants.pdf
consulté le 14/02/2018

15
 podomètres4, Google verre, etc. utilisé pour capturer les données des capteurs, pour
une analyse plus approfondie par le médecin.

Figure 3 : une figure qui représente des appareilles intelligent

4.4 Les Maisons et Les Bâtiments Intelligents

Les technologies Wi-Fi dans la domotique ont été principalement utilisées pour
plusieurs raisons (1) les appareils électroniques tels que les téléviseurs, les appareils
mobiles,… généralement pris en charge cette technologie. (2) le taux croissant
d'adoption de dispositifs informatiques mobiles comme les téléphones intelligents, les
tablettes. (3) les appareils mobiles garantissent que les consommateurs peuvent
accéder aux «contrôleurs» des appareils portables connectés à un réseau.

A l’aide du concept de l'internet des objets, les maisons et les bâtiments peuvent
exploiter alors de nombreux appareils et objets intelligemment (voir figure 4). Comme
un exemple d’application intéressante de l'IoT dans les maisons intelligentes et les
bâtiments on trouve : l’éclairage intelligent, le contrôle de l'air et de chauffage central,
la gestion de l'énergie et la sécurité. Ainsi, les réseaux de capteurs sans fil (WSN)5
avec intégration de la technologie de l’internet des objets fourniront une gestion

4
Un podomètre est un dispositif sensible au mouvement permettant de mesurer en
temps réel le nombre de pas d'une personne,
5
Un réseau de capteurs sans fil est un réseau ad hoc avec un grand nombre de nœuds qui sont
des micro-capteurs capables de récolter et de transmettre des données environnementales d'une manière
autonome.

16
intelligente de l'énergie dans les bâtiments. D’autre part, l’internet avec des systèmes
de gestion de l'énergie aussi offre la possibilité d'accéder aux systèmes d'information
et de contrôler l'énergie d'un bâtiment par un ordinateur portable ou un smartphone
placé n'importe où dans le monde.

Figure 4 : une figure qui représente un bâtiment intelligent

4.5 Le Système De Santé Electronique

L’internet des objets a rapidement transformé la prestation de soins. Les

équipements et les capteurs sont de plus en plus « intelligents » et génèrent toujours
plus de données nécessaires aux équipements médicaux, aux professionnels et
profitant ainsi aux patients, en réduisant les coûts et en améliorant leur satisfaction.
Les données ainsi collectées facilitent, adaptent, améliorent, anticipent ou réorganisent
les soins des patients.

Dans le contexte de généralisation du traitement médical électronique, l’Internet

des objets est fondamental. En effet, la conception d'un système intelligent de prise de
décision clinique, matérialisé par le stockage des données collectées sur les patients et

17
leur accessibilité universelle, procurerait au médecin un excellent appui durant la
phase de traitement (voir figure 5). L’internet des objets trouve donc tout son intérêt
dans le domaine médical, et qui aussi peut améliorer le développement dans ce
dernier.

Figure 5 : figure qui représente un système de santé électronique

4.6 Le Transport et La Mobilité Intelligent

Le développement du transport est l'un des facteurs qui indiquent le bien-être de
pays. Une application de surveillance de l'état des routes et d'alerte est l'un des
applications les plus importantes de l'IoT. Le processus a besoin de l’identification de
l'utilisateur et son trajectoire souhaité dans son application sur son téléphonique
intelligents.

Le transport intelligent est confronté à trois conceptions principales ils sont

l'analyse des transports, le contrôle des véhicules connectées.L'analyse de transport
représente l'analyse de la prédiction de la demande et de détection anomalie. Le
routage des véhicules et le contrôle de la vitesse en plus de la gestion du trafic sont
tous connu comme le contrôle du transport qu'ils ont réellement étroitement lié au

18
 véhicules connecté (par la communication V2X)6, et globalement régie par la diffusion
multi-technologie comme montre la figure 6

Figure 6 : figure sui représente les aspects de transport intelligent

4.7 Les Usines et La Fabrication Intelligente

. L'usine intelligente a ajouté une nouvelle valeur dans la révolution de la

fabrication en intégrant l'intelligence artificielle, l'apprentissage automatique et
l'automatisation du travail et la communication M2M avec le processus de fabrication.
L'usine intelligente va changer fondamentalement, comment les produits sont inventés,
fabriqués et expédiés. En même temps, cela améliorera la sécurité des travailleurs et
protège l'environnement un faible incident de fabrication. Ces progrès dans la façon
dont les machines et autres objets communiquent, et la manière dont la prise de
décision passe des humains aux systèmes techniques signifie que la fabrication devient

6
(V2X) communication :en anglais Vehicle-to-everything est le passage
d'informations d'un véhicule à une entité pouvant affecter le véhicule.
19
"plus intelligente". La révolution des industries et de la fabrication est devenue l'une
des plus technologies développées de nos jours, la croissance de l'évolution de
l'industrie a pris de nombreuses générations. La première génération liée aux machines
mécaniques en plus de la puissance de l'eau et du courant. La deuxième génération de
l'industrie traite de la production de masse, des chaînes de montage et de l'électricité.
Dans la fin du dernier siècle, les industries sont exploitées sous le contrôle des
ordinateurs et de l'automatisation qui est reconnu par la troisième génération
d'industries. L'industrie intelligente c’est la quatrième génération connue par l'industrie
4.0 est basée sur les systèmes de chiffrement physiques qui est capables de se
connecter à Internet. Le concept de l'industrie 4.0 avec l'Internet des objets peut
atteindre de grandes attentes pour les accords de résolution des industries avec de
nombreux aspects sont illustrés à la figure 7.

Figure 7 : figure qui représente un schéma de l’industrie 4.0

4.8 La Surveillance à Distance Des Patients

Ce domaine d’application est déployé pour surveiller à distance les paramètres

essentiels du patient par l'utilisation de capteurs, de dispositifs et les objets qui les
entourent (voir figure 8). En cela, les données critiques du patient sont transmises et
partagées en temps réel entre le patient et les soignants. Sa principale pertinence est la

20
gestion des maladies chroniques telles que le diabète, les maladies cardiaques, asthme,
etc… (Alok Kulkarni,2014)

Figure 8 :figure qui représente le mécanisme de la surveillance distants des patients

5. Les Composants De L’IOT

Nous avons entendu parler de l'Internet des objets, l’IoT qui permet la connexion
de nos appareils intelligents et des objets au réseau pour fonctionner efficacement et à
distance. Ce point répond à la question : quelles sont les principales composantes de
l'Internet des objets ?

Le tableau suivant présente les composants principaux de l’IOT:

Comp La description
osants IoT

Objets Un objet connecté est un objet physique équipé de capteurs ou d’une puce qui lui
physiques permettent de transcender son usage initial pour proposer de nouveaux services. Il s’agit
d’un matériel électronique capable de communiquer avec un ordinateur, un smartphone
ou une tablette via un réseau sans fil (Wi-Fi, Bluetooth, réseaux de téléphonie mobile,

21
 réseau radio à longue portée de type Sigfox ou LoRa, etc.), qui le relie à Internet ou à un
réseau local7.

Capteurs Ils sont installés sur les es objets connectés, ils sont plus ou moins intelligents,
selon qu’ils intègrent ou non eux-mêmes des algorithmes d’analyse de données, et qu’ils
soient pour certains auto-adaptatifs. Les capteurs connus sont : Capteurs de température
et thermostats, Capteurs de pression, Humidité / niveau d’humidité, Détecteurs
d'intensité lumineuse, Capteurs d’humidité, Détection de proximité, Étiquettes RFID….

Gens Exemple : Les humains peuvent contrôler l'environnement via des applications
mobiles

Exemple : Services Cloud - peuvent être utilisés pour:

Prestations de
service
• Traiter les Big Data et les transformer en informations précieuses

• Construire et exécuter des applications innovantes

• Optimiser les processus métier en intégrant les données de l'appareil.

Elle est considérée comme un type d'intergiciel utilisé pour connecter les
Plateformes
composants IoT (objets, personnes, services, etc.) à l’environnement l'IoT. Elle fournit
de nombreuses fonctions :

• Accès aux appareils

• Assurer une installation / un comportement correct de l'appareil

• Analyse des données

• Connexion interopérable avec le réseau local, le cloud ou d'autres périphériques.

Réseaux Les composants IoT sont liés entre eux par des réseaux, utilisant diverses technologies,
normes et protocoles sans fil et filaire .

Tableau 1 : Les composants de base d’un système IOT

7
http://www.smartgrids-cre.fr/index.php?p=objets-connectes-definition consulté le 01/03/2018

22
 6. Les Défis de l’IOT
Il y a des défis à l’application de l'Internet des objets de point de vu coût de la
mise en œuvre du fait que l'attente de la technologie doit être disponible à faible coût
avec un grand nombre d'objets. De plus, l’IoT sont également face à de nombreux
autres défis qui se résument dans cinq sous sections suivantes.

6.1 La Découverte Automatique

Dans les environnements dynamiques les services appropriés pour les objets
doivent être identifié automatiquement. Ceci nécessite des moyens sémantiques
appropriés pour décrire leur fonctionnalité afin de les exploiter d’une manière efficace.

6.2 L’Interopérabilité

Chaque type d'objets intelligents dans l'Internet des objets possède différents
capacités de stockage d'information, de traitement et de communication. Différents
objets intelligents serait également soumis à des conditions différentes telles que la
disponibilité de l'énergie et les besoins en bande passante de communications. A cet
effet, pour faciliter la communication et coopération de ces objets, des normes
communes sont requises.

6.3 La Sécurité et La Confidentialité

Les aspects de sécurité et de protection d'Internet tel que la confidentialité des

communications, l'intégrité des messages ainsi que l'authenticité et la fiabilité de
partenaires de communication doivent être assurés dans un environnement IoT à titre
d’exemple dans certain cas il y a un besoin d'accéder à certains services pour
accomplir une tâche ou d'empêcher de communiquer avec d'autres objets dans le IoT
pour des raisons préventive de sécurité. De plus, d'autres exigences selon la
particularité du domaine d’application, doivent être aussi considérées comme par
exemple dans les transactions commerciales des objets intelligents doivent être
protégés des yeux des concurrents.

23
 6.4 La Tolérance Aux Pannes :

les objets dans IOT sont beaucoup plus dynamiques et mobiles que les
ordinateurs Internet, et dans un changement rapide et de manière inattendue. Pour
structurer Internet des objets d'une manière robuste et digne de confiance on utilise la
redondance en plusieurs niveaux pour l’adaptation automatique au changement de
conditions.

6.5 L’Auto-Organisation

Les objets intelligents ne devraient pas être gérés comme des ordinateurs qui
nécessitent leurs utilisateurs pour les configurer et les adapter à des situations
particulières. Les objets mobiles, qui sont souvent utilisées de façon sporadique,
doivent établir spontanément des liens et pouvoir être organisé et configurer par eux-
mêmes en fonction de leur environnement d’exécution (Zeinab Kamal ,2017)

7. Conclusion
Dans ce chapitre on a présenté une étude détaillée sur l’internet des objets
, sa définition leurs domaine d’application .puis les principaux composant de IoT ,
et ses défis. Parmi les défis majeurs de l’IOT c’est la tolérance aux fautes qui est l’une
des techniques assurant la sûreté de fonctionnement, les notions relatives aux solutions
de ce défi seront présentées dans le chapitre suivant.

24
 Chapitre 2 : La Tolérance au fautes
dans L’internet des objets (IOT)
1. Introduction
L’Un des problèmes de l’IOT est sa sûreté de fonctionnement qui est une forte
contrainte spécialement si elle concerne un système médical.

Nous présentons dans ce chapitre brièvement les concepts de base de la

tolérance aux fautes; nous donnons tout d’abord quelques définitions, puis les modèles
et hypothèses de fautes. Puis, nous présentons les différentes approches existantes
utilisant la tolérance aux fautes dans l’internet des objets et spécialement celles qui
touche le domaine médical.

2. Définitions
Cette section présente un ensemble de notion de base liée à la sûreté de
fonctionnement.

2.1 La Sûreté De Fonctionnement

La sûreté de fonctionnement d’un système informatique est la propriété

qui permet à ses utilisateurs de placer une confiance justifiée dans le service qu’il leur
délivre. Le service délivré par un système est son comportement tel que perçu par son
ou ses utilisateurs. Ces derniers peuvent être vu dans un système IoT à travers la sûreté
de fonctionnement des objets du système considéré, ses objets peuvent être humain ou
physiques qui interagissent entre eux.

2.2 Les Attributs De La Sureté De Fonctionnement

 la disponibilité qui évalue la capacité d’être prêt à rendre le service ;

 la fiabilité qui cherche la continuité du service ;

 la sécurité-innocuité qui est définie par la non-occurrence de

conséquences catastrophiques pour l’environnement ;

25
  la confidentialité qui recommande la non-occurrence de divulgations
non-autorisées de l’information ;

 l’intégrité qui permet la non-occurrence d’altérations non appropriées du

système ;

 la maintenabilité est l’aptitude aux réparations et aux évolutions.

2.3 Les Moyens D’Assurer La Sureté De Fonctionnement

Les moyens d’assurer la sureté de fonctionnement sont définis comme les

méthodes utilisées pour assurer cette propriété. On distingue quatre méthodes
principales.

• La prévention des fautes vise à empêcher l’apparition ou l’introduction

des fautes dans le système. Elle repose sur des règles de développement
(modularisation, utilisation de langage fortement typé, preuve formelle, etc.).

• L’élimination des fautes s’attache à réduire la présence (nombre,

sévérité) des fautes. Cette méthode opère à la fois lors du développement (vérification
des conditions, test de régressions, injection de fautes, etc.) ou lors de l’utilisation
(maintenance).

• La prévision des fautes cherche à estimer (qualitativement et

quantitativement) l’occurrence et les conséquences des fautes. Elle est réalisée par la
modélisation et l’évaluation de systèmes.

• La tolérance aux fautes essaie de masquer l’occurrence des fautes et de

continuer à fournir le service demandé malgré leur apparition.

2.4 La Tolérance Aux Fautes

C’est l’une des techniques assurant la sûreté de fonctionnement. Elle signifie que
le système continue de fonctionner même en présence d’une faute. Elle a l’avantage
d’être moins coûteuse par rapport aux approches basées sur la prévention des fautes.
Cette dernière, exigent un personnel qualifié et des méthodes spécifiques telles que les
révisions de conception, l’analyse des composants ainsi que des essais pour la

26
construction du matériel .En outre, elles nécessitent une programmation structurelle,
une modularisation, et des techniques de vérification formelle pour vérifier la fiabilité
des logiciels. La tolérance aux fautes est mise en œuvre par la détection d’erreur et le
rétablissement du système.

2.5 La Détection d’Erreur

La détection d’erreur peut être réalisée lors d’une suspension de service. On dit
alors qu’elle est préemptive. À l’opposé, on dit qu’elle est concomitante lorsqu’elle est
réalisée lors de l’exécution normale du service.

Les techniques de détection concomitante utilisent la redondance au niveau

information ou composant,. Les formes les plus utilisées sont les suivantes.

• Les codes détecteur d’erreur : ils introduisent une redondance dans la

représentation de l’information .

• Le doublement et la comparaison : les unités de traitement sont

dupliquées et leurs résultats sont comparés.

• Les contrôles temporels et d’exécution : un « chien de garde »

(watchdog) contrôle les temps de réponse ou l’avancée de l’exécution.

• Les contrôles de vraisemblance ou de données structurées : des

assertions sont insérées dans le code pour vérifier quelques contraintes comme les
types, les indices, les valeurs, etc.

2.6 Le Rétablissement Du Système

Le rétablissement du système vise à transformer l’état erroné en un état exempt

de faute. Le traitement de la faute se fait en identifiant le composant fautif et en
l’excluant. Le traitement de l’erreur peut se faire par trois techniques : la reprise, la
poursuite et la compensation.

. La reprise est la technique la plus couramment utilisée. L’état du système

est sauvegardé régulièrement. Lorsqu’une erreur est détectée, le système est ramené à

27
un état antérieur à l’occurrence de l’erreur. Cet état sauvegardé est appelé point de
reprise.

. La poursuite consiste à rechercher un nouvel état exempt d’erreur. Ceci

peut par exemple être réalisé en associant un traitement exceptionnel lorsqu’une erreur
est détectée. Le but de ce traitement est alors de corriger l’état erroné.

. La compensation nécessite que l’état du système comporte suffisamment

de redondance pour permettre sa transformation en un état exempt d’erreur. Elle est
transparente vis-à-vis de l’application car elle ne nécessite pas de ré exécuter une
partie de l’application (reprise), ni d’exécuter une procédure dédiée (poursuite). Elle
peut par exemple être réalisée en répliquant des composants et en effectuant un vote
majoritaire sur les résultats. Une autre manière de procéder est d’utiliser les codes
correcteurs d’erreurs ou plus généralement des algorithmes tolérants aux fautes.

On peut noter que la méthode de compensation ne nécessite pas de détection

d’erreurs spécifique puisqu’elle effectue elle-même la détection d’erreur. Une méthode
de compensation peut servir de détecteur d’erreur, tandis que l’inverse n’est pas vrai.
En effet, la compensation nécessite une redondance plus importante pour pouvoir
corriger l’erreur. La redondance peut être au niveau donnée (comme les bases de
données), code (comme la n_version de programmation) ou composant (une principale
et autre dite secondaire qui peut être en mode passif, actif ou semi actif).

(Xavier,2010).

3. Les Modes De Défaillance et Les Hypothèses

Sur l’axe des valeurs, on peut distinguer :

• Les erreurs arbitraires de valeur. La valeur rendue par le service ne

fait pas partie de l’ensemble des réponses spécifié pour ce service. Cette définition est
la plus générale, l’adjectif «arbitraire» souligne le fait que la définition ne pose aucune
restriction sur la valeur erronée.

• Les erreurs de valeur hors-code: la valeur rendue par le service est

hors du code qui spécifie l’ensemble des réponses possibles pour tous des services.

28
Ces erreurs sont faciles à détecter, on peut utiliser un code détecteur d’erreur à cette
fin.

Sur l’axe temporel on distingue plusieurs types d’erreurs.

• Les erreurs temporelles arbitraires : il s’agit du cas le plus général

où la réponse n’est pas rendue dans l’intervalle de temps spécifié.

• Les erreurs par omission : la réponse du service à une requête n’est pas
et ne sera jamais rendue.

• Les erreurs par avance : la réponse est rendue en avance par rapport au
service attendu.

(Taha Bennani, 2005)

4. La Tolérance Aux Fautes et l’IoT Médical

Comme il existe très peu de travaux sur la tolérance aux fautes dans IoT
médical. Zaiter (Zaiter, 2017) a motionné que cela est dû au fait que certains systèmes
médicaux ne considèrent pas la sûreté de fonctionnement d’une manière générale dans
leur mise en œuvre tant dis que des travaux donnent uniquement des consignes telles
que l’isolation des nœuds défectueux, la proposition de mesures pour chaque pré-
phase dans le cycle de développement et de mise en œuvre du système médical. Les
auteurs dans (Zaiter, 2015) ont mentionné que d’autres travaux traitent un sous-
ensemble des fautes qui peuvent se produire comme la considération uniquement du
problème de la batterie. Ainsi, le problème de pertes des paquets n’est pas résolu dans
une solution qui vise à traiter les problèmes de la communication et des fautes
environnementales.

Dans (Gia, 2015) les auteurs proposent une architecture IoT évolutive pour les
soins de santé. La tolérance aux pannes est obtenue via la sauvegarde de routage entre
les nœuds et les états des services pour maintenir la connectivité entre les nœuds du
système. Dans cette solution, la sauvegarde dans un système IoT dont les équipements
n'ont pas une puissance de traitement et une mémoire suffisante pour stocker des
copies de sauvegarde de grande taille ce qui peut freiner l’efficacité de cette solution.

29
 Une autre solution dans un système IoT médical de contrôle de glucose (Zilic, 2011)
utilise plusieurs capteurs de glycémie (redondance matériel) pour détecter les fautes et
assurer une disponibilité da la valeur de la glycémie. Dans le même contexte de
solution un graphe coloré est utilisé pour tolérer l’existence des fautes (Zilic, 2011).
Comme le matériel dupliqué est de même nature c’est fort possible d’être déséquilibré
dans certain cas de faute, comme le bruit fort, en même temps.

Les solutions trouvées se basent sur

 La réplication du matériel sachant qu’on ne peut pas tous dupliquer dans un

système IoT médical

 Une demande excessive du matériel comme (la sauvegarde).

Tous ces solutions sont considérées comme coûteuse à réaliser.

5. Conclusion
La tolérance aux fautes est un problème important pour l'IoT. Selon la
déclaration de l'IETF8 des concepts de l'IoT, le but de la tolérance aux fautes dans
l'Internet des objets est de « maintenir robuste et confiance un réseau dynamique ». On
a présenté dans ce chapitre quelque concepts générales relatifs à la sûreté de
fonctionnement et spécialement celles qui concernes la tolérance au fautes ainsi que
les solutions technique dans l’IoT et le chapitre suivant détail la notre contribution
dans ce domaine.

L’internet Engineering Task Force est un groupe informel ouvert a tout individu qui participe a
8

l’élaboration des standard internet

30
 Chapitre 3 : La Conception De La
Proposition

1. Introduction
Nous présentons dans ce chapitre notre travail qui consiste à ça proposition
d’une solution de tolérance aux fautes dans un environnement IoT médical contrôlé
par un SMA. Nous concentrons sur notre proposition qui exploite la n-version de
programmation, ce dernier considère les caractéristiques des systèmes IoT médicaux.

Nous commencerons par la présentation du contexte du travail puis les détails

théoriques de notre proposition et finalement nous présentons la conception détaillée
de cette proposition en utilisant le langage de modélisation AUML.

2. Le Contexte et l’Objectif
Un système médical domotique basé sur les principes de l’IoT est employé pour
surveiller intelligemment les patients au sein de leur maison. Ce système peut cesser
de fonctionner à n’importe quel moment à cause d’occurrence de faute, pour cette
raison notre objectif est d’ajouter un plus pour maintenir ce système dans un état sain
en évitant l’inconvénient des solutions matériel présentées dans le chapitre précédent.

Les techniques de réplication sont largement utilisées (voir chapitre 2). Dans ce
contexte la réplication de code est une forme employée la n-version de
programmation. Cette dernière consiste à créer des alternatives de réponse en cas de
détection de faute.

Notre système médical est contrôlé par un SMA et notre objectifs est de crée des
codes alternatifs se base sur l’architecture du mécanisme du contrôle (voir figure 9).

3. Le Détaille De La Proposition
Cette proposition se base sur l’emploi des contrôleurs comme étant des agents
pour résoudre le problème de non disponibilité de l’information. Deux types d’agents

31
sont employés (voir la figure 9) un ensemble d’agents contrôleurs locaux (noté Acl)
chacun simule un équipement médical et un seule agent contrôleur global noté ACG.

Les tâches déléguées à l’ACG sont les suivantes :

 Connecté et contrôler tous les autres agents.

 En cas d’une faute il l’annonce. et propose dans ce cas des alternatives

de réponse

Chaque ACL (agent contrôleur local) permet de:

 un contrôle individuel de chaque entité,

 la génération des nombre aléatoire qui représente la collection des

entrée et les valeur fournis, par un équipement, des signes
physiologiques..

 L’envoi les valeurs des signes à l’agent contrôleur globale.

Nous notons que nous concentrons sur le fonctionnement d’ACG qui génère les
alternatives de réponses.

3.1 L’Architecture du système de contrôle :

Notre système de surveillance est contrôlé par un SMA selon l’Architecture
suivant :

Figure 9 : l’architecture du mechanisme du contrôle

32
 Notre solution intègre la notion de n-version de programmation en exploitant les
formules (1, 2 et 3) ci-après :

Sachant que Spo2 : est la saturation de l’oxygène

Spo2= ((battement de cœur×100))⁄Q (1)

Tel que :

Q=2ml ×la pression pulsée× battement de cœur (2)

Et

La pression pulsée= systolique – diastolique (3)

Alors le code exploitant ces formules est intégré dans le comportement des
agents. Ces codes sont utilisés en cas de l’occurrence d’une faute de fonctionnement
d’une entité. (ziater,2017)

4. La Conception Détaillée De Notre Proposition

Dans notre conception on présente la description graphique basée sur les trois
diagrammes de langage AUML qui sont : diagramme de classes, diagramme de
séquence et diagramme d’activité.

4.1 Brève description d'AUML

AUML « Agent UML » est un projet relativement jeune proposé en 1999 et les
premiers travaux de spécification ont débuté en 2003. AUML vise à proposer un
ensemble de notations mieux adaptées au paradigme multi-agent, en étendant le
langage UML.

AUML adopte trois niveaux de représentations :

 Niveau1 : représentez le protocole global (diagramme de séquence,

Package, Template).

 Niveau2 : une représentation des interactions entre les agents

(diagramme de séquence, activités, collaboration, état)

33
  Niveau3 : une représentation interne aux agents (diagramme d’activité,
et d’état de transition)9
4.2 La Représentation De La Vue Statique Des Agents
Contrôleurs

Nous avons employé le diagramme de classe pour représenter la vue statique

4.2.1 Le Diagramme De Classe

Figure 10 : une figure qui représente le diagramme de class

9
https://www.memoireonline.com/10/12/6375/m_La-generation-des-diagrammes-AUML--
partir-dun-programme-Jade1.html consulté le 28/04/2018

34
 4.3 La Représentation De La Vue Dynamique Des Agents
Contrôleurs

Les diagrammes présentés dans cette partie montrent la vue dynamique de

notre système et les différentes interactions .

4.3.1 Le Diagramme De Séquence «ajouter composant »

Nous exploitons la description textuelle de ce cas d’utilisation pour spécifier les
interactions des acteurs de système (simulateur) .

Titre : ajouter un composant

Résumé : Ce cas d’utilisation permet à l’utilisateur d’ajouter un composant au

système.

Acteur : l’utilisateur. L’agent contrôleur globale

Précondition :
- S’authentifier.

Scénario nominal :
1. L’utilisateur demande d’ajouter un composant.

2. L’utilisateur remplis un premier formulaire contient le nom de composant et

le nombre de paramètre puis le deuxième formulaire qui contient le nom de chaque
paramètre et la valeur maximum et minimum.

3. L’agent contrôleur globale crée un nouvel agent avec les paramètres saisis. Ce
dernier commence son comportement de génération des valeurs des signes
physiologiques et les envois à l’ACG.

4. L’agent contrôleur globale enregistre les valeurs reçu dans la base de donné
et affiche le dans l’interface.

Enchainements alternatifs :
A2 : les informations sont incomplètes

Le scénario nominal reprend au point 1.

35
 Post condition :
- composant ajouté

-agent crée

Figure 11 : Diagramme de séquence «ajouter composant

4.3.2 Le Diagramme De Séquence «afficher statistique »

Nous exploitons la description textuelle de ce cas d’utilisation pour spécifier les
interactions des acteurs de système (simulateur). Ce cas permet d’afficher les
statistiques concernant le fonctionnement des composants du système en choisissant
un patient.

Titre : afficher les statistiques

36
 Résumé : Ce cas d’utilisation permet à l’utilisateur d’afficher les statistiques sur
le fonctionnement des composants du système en choisissant un patient.

Acteur :

l’utilisateur.

Précondition :
- S’authentifier.

Scénario nominal :
1. L’utilisateur demande d’afficher les statistiques.

2. L’utilisateur remplis le formulaire contenant le nom de patient et leur ID.

3. le système recherche sur le nom et id puis récupérer son valeur depuis la base
de données.

4. le système affiche les valeurs des signes physiologiques dans un fichier pdf
avec les informations sur les fautes déclenchées et aussi les informations sur les signes
physiologiques après l’utilisation de formules 1,2 et 3.

Enchainements alternatifs :
A2 : les informations sont incomplètes

Le scénario nominal reprend au point 1.

A3 : le patient n’existe pas .

Le scénario nominal reprend au point 2.

Post condition :
- les statistiques affichées.

37
 Figure 12 : Diagramme de séquence «afficher statistique »

4.3.3 Le Diagramme De Séquence « injecter faute »

Nous exploitons la description textuelle de ce cas d’utilisation pour spécifier les
interactions des acteurs de système (simulateur). Ce cas permet d’injecter une faute
sous forme d’un virus qui arrêtera le fonctionnement d’un agent contrôleur local.

Titre : injecter faute.

Résumé : Ce cas d’utilisation permet à l’utilisateur de d’injecter une faute.

Acteur : l’utilisateur, agent contrôleur globale.

38
 Précondition :

- S’authentifier.

-afficher l’état de système

Scénario nominal :

1. L’utilisateur demande d’injecter une faute.

2. le système demande de choisir le type de faute

3. l’utilisateur sélectionne le type de faute.

4. L’agent contrôleur globale crée un agent virus.

5. L’agent virus envoie un message vers l’agent associé à l’équipement concerné

par la faute.

6. L’agent qui reçoit le message s’arrête pendant 5 secondes.

7. L’agent contrôleur globale notes que l’un des valeurs absent donc signale une
faute.

8. L’agent contrôleur globale utiliser les formules (1) (2) (3) pour récupérer les
valeurs.

Post condition :

Système en état d’alerte.

Enchainements alternatifs :
A3 : le choix n’est pas sélectionner

Le scénario nominal reprend au point 2.

39
 Figure 13 : Diagramme de séquence «Injecter faute »

4.3.4 Le Diagramme De Séquence « afficher l’état de système »

Nous exploitons la description textuelle suivante de ce cas d’utilisation pour
spécifier les interactions des acteurs du système (simulateur), de plus ce cas exploite
l’ « id » d’un patient pour afficher l’état de fonctionnement des composants du
système et les valeurs des signes de ce patient.
40
 Titre : afficher l’état de système.

Résumé :

Ce cas d’utilisation permet à l’utilisateur d’afficher l’état de fonctionnement des

composants du système et les valeurs des signes du patient.

Acteur :

l’utilisateur, Agent contrôleur globale, agent ECG, Agent Oxymètre, Agent

Tensiomètre.

Précondition :

- S’authentifier.

Scénario nominal :
1. L’utilisateur demande d’afficher l’état de fonctionnement des composants du
système et les valeurs des signes du patient.

2. L’agent contrôleur globale demande aux agents Oxymètre, ECG, Tensiomètre

d’envoient les valeurs (saturation d’oxygène, battement de cœur .systolique,
diastolique) ces derniers qui génère par ces derniers

3. L’agent contrôleur globale enregistre les valeurs reçu dans la base de donné
et les affiches sur l’interface.

Post condition :
- état affiché.

41
 Figure 14 : Diagramme de séquence « afficher l’état de système »

4.3.5 Le Diagramme d’activité « injecter faute «

Nous donnons une représentation des activités des agents inclus dans le cas
injecter faute ( voir le figure 17)

42
 Figure 15 : Diagramme d’activité « injecter faute «

4.3.6 Le Diagramme d’activité « afficher l’état de système «

Pour une représentation plus clarifiés du processus d’interaction, on utilise aussi
les diagrammes d’activités .Nous donnons une représentation des activités des agents
inclus dans le cas afficher l’état de système (voir la figure 15).

43
 Figure 16 : Diagramme d’activité « afficher l’état de système

4.3.7 Le Diagramme d’activité « ajouter composant«

Nous donnons une représentation des activités des agents inclus dans le cas
ajouter composant (voir le figue 16).

44
 Figure 17 : Diagramme d’activité « ajouter composant «

5. Conclusion
La conception est une étape très importante qui précède l’implémentation de tout
le système. A travers ce chapitre, nous avons pu concevoir le déroulement de notre
solution de N-Version de programmation en se basant sur les diagrammes du langage
AUML à savoir le diagramme de classe le diagramme de séquence et le diagramme
d’activité. Dans le prochain chapitre nous allons montrer les outils techniques
permettant la réalisation de notre proposition et un aperçu sur les fonctionnalités
réalisées.

45
 Chapitre 4 : L’Implémentation De
La Proposition

1. Introduction
Dans ce chapitre on va présenter deux parties principales : la première partie
dévoile l’environnement de développement qui contient les différents langages et
technologies, et la deuxième partie présente la description de la simulation notre
proposition ainsi que les interfaces permettant son déroulement.

2. La Représentation Des Technologies et Les

Langages
Cette partie concerne la présentation des outils technologiques

2.1 phpMyAdmin

phpMyAdmin (PMA) (voir figure 18) est une application Web de gestion pour
les systèmes de gestion de base de données MySQL réalisée principalement en PHP et
distribuée sous licence GNU GPL..10

Figure 18 : figure qui représente le logo de phpmyadmin

2.2 Eclipse

Eclipse (voir figure 19 ) est un projet organisé en un ensemble de sous-projets

de développements logiciels visant à développer un environnement de production de
logiciels libre qui soit extensible, universel et polyvalent, en s'appuyant principalement
sur Java.

10
https://en.wikipedia.org/wiki/PhpMyAdmin consulté le 29/05/2018

46
 Son objectif est de produire et fournir des outils pour la réalisation de logiciels,
englobant les activités de programmation. Son IDE, partie intégrante du projet, vise
notamment à supporter tout langage de programmation à l'instar de Microsoft Visual
Studio.11

Figure 19 : figure qui représente le logo d’eclipse

2.3 Jade

Java Agent Développement Framework, ou JADE (voir figure 20), est un

Framework logiciel pour le développement d'agent intelligent, implémenté en Java. Le
système JADE prend en charge la coordination entre plusieurs agents FIPA et fournit
une implémentation standard du langage de communication FIPA-ACL, ce qui facilite
la communication entre agents. JADE a été initialement développée par Telecom Italie
et distribué sous forme de logiciel libre.

Figure 20 : figure qui représente le logo de JADE

3. La Description De La Simulation
Notre simulation repose sur la définition des composants du système, la création
des agents et l’injection de fautes pour tester l’efficacité de notre proposition. Le
scénario type de cette simulation est détaillé comme suit : dès que la faute est injecté
l’ACG exploite les fonctions de corrélation présentée par les formules (1,2,et 3). Donc
l’agent exploite les services pulsation, le débit cardiaque offert par l’agent du
tensiomètre pour valider la formule si par exemple la faute concerne la saturation
d’oxygène.

11
https://fr.wikipedia.org/wiki/Eclipse_(projet) consulté le 29/05/2018

47
 Cette partie contient les principales fonctionnalités servant à manipuler le
simulateur de notre proposition,

3.1 L’Authentification

La figure suivante (figure 21) permet aux utilisateurs de s’authentifier.

L’utilisateur doit taper le nom d’utilisateur et le mot de passe adéquat. S’ils sont
valides il accède à la page d’accueil de la simulation (voir figure 22) Sinon il affiche
un message d’erreur au-dessus du formulaire. Le système aussi offre à l’utilisateur de
s’inscrire s’il n’est pas déjà un membre.

Figure 21 : présentation de l’Interface De l’Authentification

A la connexion deux événements se produisent :

 l’affichage de l’interface du simulateur.

 La création de l’agent contrôleur globale qui lance l’interface du

simulateur, et crée 3 agents contrôleurs locaux ECG, Oxymètre,
Tensiomètre chaque agent dans un conteneur défèrent comme montre les
figure 22,23.

Les tables qui ont été créer automatiquement dans la base de donné sont : user,
patient (voir le figure 24)

48
 Figure 22 : présentation de interface principale du simulateur

Figure 23 : figure qui représente l’interface jade avec des agents crées

49
 Figure 24 : figure qui représente la base de données

3.2 L’Ajoute D’un Patient

Dans la figure 25 l’onglet « ajouter patient » est ouvert car il est le premier
onglet, les champs qui sont affichés doivent être rempli pour ajouter un patient.

Après le remplissage des champs un onglet sera ajouter a l’état de système (voir
le figure 26), et quatre tables seront créés dans la base données selon l’id ajouté (voir
figure 27).

Figure 25 : figure qui représente un exemple d’ajouter patient

50
 Figure 26 : la représentation de l’état de système après l’ajout d’un patient

Figure 27 : la maj de la base de données après l’ajout d’un patient

3.3 L’Affichage D’état Du Système

Pour afficher l’état du système il suffit de cliquer sur l’onglet « l’état de
système » : les valeurs simulées, générées automatiquement par les agents contrôleurs
locaux , comme le battement de cœur (BC), la saturation d’oxygène (SPO)…etc sont

51
reçus chaque seconde par l’agent contrôleur globale ( voir figure 28 ) ces derniers
seront affichées dans des progresses barres (voir figure 29)

Figure 28 : représentation d’échange des valeurs entre les agents en utilisant

l’agent Sniffer.

Figure 29 : une figure qui représente l’état de système

52
 3.4 L’Ajoute D’un Composant

L’ajout d’un composant passe par deux étapes, la première étape demande le
nom de composant qui sera le nom de l’agent associé, et aussi le nombre de
paramètres envoyer par cet agent (voir figure 30).

Figure 30 : 1ere formulaire d’ajout d’un composant

La deuxième étape demande le nom et la valeur max et min de chaque

paramètre(voir figure 31 ) qui sera generé par l’agent ,en cliquant sur le button
« ajouter » le simuateur :

 Crée un nouvel agent avec le nom de composant tappé (voir figure 32)

53
Figure 31 : 2eme formulaire d’ajoute d’un composant

Figure 32 : : la création d’un nouveau agent

54
  Affiche le panneau qui contient les nouvelles valeurs générées (voir figure 33) :

Figure 33 : l’état de système avec l’ajout de nouveau composant

3.5 Le Déclenchement D’une Faute

Pour simuler l’occurrence des fautes on doit cliquer sur le bouton « déclencher
faute », le système affiche la fenêtre ci-dessus(voir figure 34 ) :

Figure 34 : une fenêtre demande le choix du type de faute

55
 Par exemple On choisit « Oxymètre » : l’agent contrôleur globale crée un
agent virus comme la figure 35 montre et signale le panneau où la faute est survenue
(voir figure 36).

Figure 35 : interface jade qui montre la création du virus.

Figure 36 : figure qui représente le clignotement du panneau spo

56
 3.6 L’Affichage Des Statistiques

Pour afficher les statistiques montrant les avantages de l’utilisation de la N-

version de programmation. Pour cela nous devons exploiter les données d’un patient, on
doit saisir son id, nom et prénom (voir figure 37) :

Figure 37 : figure qui représente le formulaire de d’affichage les statistique

Lorsque on clique sur le bouton « afficher », le système crée et ouvert un fichier

pdf qui contient :

 Le nom, le prénom, la date de naissance de patient et la date de

réalisation du fichier

 Un tableau où les colonnes sont les signes vitaux qui était enregistrés
dans la base de donnée (saturation d’oxygène (SPO2), battement de cœur
(BC)..etc.

Sachant que :

 etatN : signifie les valeurs reçues par l’agent contrôleur sans l’exploitation
des formules (1), (2), et (3) « même en cas de faute ».

57
 etatC : les valeurs reçues par l’agent contrôleur avec l’utilisation des
formules (1), (2), (3) en cas de faute.

Figure 38 : un exemple des résultats obtenus

58
 3.6.1 La discussion des résultats
Cette sous partie a pour but de montrer l’utilité de la n version de
programmation pour l’assurance de la disponibilité des informations concernant l’état
de santé du patient. Nous montrant ca à travers un exemple.

On prend la ligne 11 dans le tableau des résultats obtenus (voir le figue 39) et en
utilisant les formule (1),(2),(3) manuellement pour expliquer la signification d’une
ligne :

Figure 39 :figure qui représente exemple des résultats dans un moment précis (un état
d’alerte)

Pression pulsée=systolique-diastolique Pression pulsée=15-13=2

Q=2ml* Pression pulsée*battement de cœur Q =2*1*87=348

Spo2 = battement de cœur*100 / Q SPO2 = 87*100/348=25

3.6.2 la discussion des statistiques montant l’utilité de l’emploi de la

n- version de programmation
L’utilisation de la n version de programmation a permis de garder la
transparence, en cas de faute, exigée pour toute solution de tolérance aux fautes et la
figure suivante montre l’interface à afficher au niveau du centre de santé (voir figure
40).

59
 Figure 40 :figure qui représente l’alerte au niveau de ECG et la valeur de BC calculée

Si on veut envoyé l’état de patient (on concentrant sur la colonne de spo2) sans
utilisation de n- version, les dix premiers valeurs avant le déclenchement de fautes et
après la faute l’agent envoi la valeur 0 sont présentées dans la figure suivante (voir le
figure 41 ).

Figure 41 :figure qui représente les valeur de spo envoyé sans l’utilisation de n-version
de programmation

60
 Avec n version de programmation : l’état du patient envoyé avec la valeur
calculé de spo2, les premiers dix valeurs avant le déclenchement du faute et les dernier
valeurs (25,25,25,50) (voir le figure 42) sont calculé grâce a l’utilisation des formules
(1)(2)(3). La couleur rouge indique qu’il y a une faute qui a été déclenché et on disant
qu’une alerte est déclenchée au centre de santé médical.

Figure 42 : une figure qui représente les valeurs envoyées au centre de santé médical
avec utilisation de la n-version de programmation

L’emploi des formules 1, 2, et 3 comme une alternative aide d’un côté à assurer
une disponibilité de l’information, et de diagnostiquer et décider sur l’état de santé du
patient le plus vite possible d’un autre côté.

4. Conclusion

La partie de réalisation donne une idée plus claire sur notre proposition. Dans ce
chapitre nous avons présenté notre simulation par la présentation de ses principales
interfaces graphiques. Enfin grâce à cette simulation nous avons pu montrer l’utilité de
notre proposition.

61
 Conclusion général
Au cours de ce mémoire, nous avons présenté au début une vue générale sur
l’internet des objets puis un état de l’art sur les concepts relatifs au traitement des
fautes dans la littérature comme la réplication. Nous avons aussi vu, dans le chapitre 2
le traitement des fautes dans les systèmes IoT médicaux. Nous avons présenté par la
suite les différents aspects théoriques de notre proposition notamment les étapes de
conception et de réalisation de notre simulateur. Afin de modéliser notre proposition,
nous avons commencé par la conception de notre système en utilisant le
formalisme AUML, et pour la réalisation il y a plusieurs technologies qui ont été
nécessaires. Ces dernières sont présentées dans le dernière chapitre on citera donc le
langage de programmation java pour la réalisation des interfaces ainsi que la
programmation des agents. Ces derniers sont manipulés en exploitant la plate-forme
JADE qui permet de construire des systèmes multi agents (SMA). Nous avons aussi
utilisés MySQL pour l'élaboration des requêtes d'interrogation de la base de donnée, et
enfin l’environnement de développement eclipse pour l'écriture du code.

Les difficultés que nous avons rencontrées est de savoir comment intégrer les
formules au niveau de comportement de l’agent et gère les interactions entre ces
agents, spécialement en déclenchant les fautes a travers le simulateur.

De notre point de vu, notre solution de tolérance aux fautes est vue comme une
solution logicielle pas chère car et les formules sont exploitées comme une alternative
de réponse permet de réagir rapidement si l’état de santé du patient surveillé est grave,
par au moins signaler une alerte au niveau du centre de santé avec les valeurs des
signes calculées.

Nous espérons expérimenter cette solution sur des équipements réellement

connecté.

En effet, ce travail étant une œuvre humaine, n'est pas un modèle unique et
parfait, c'est pour raisons que nous restons ouverts à toutes les critiques et nous
sommes prêts à recevoir toutes les suggestions et les remarques tendant à améliorer
d'avantage cette étude

62
 Bibliographie
 (Alok Kulkarni,2014) Alok Kulkarni, Sampada Sathe (2014). Healthcare
applications of the Internet of Things: A Review. (IJCSIT) International Journal of
Computer Science and Information Technologies, Vol. 5 (5) , 2014, 6229-6232

 (André Pedroza,2016)André Pedroza dos Santos, Dalfrede Welkener Soares Lima,

Fhelipe Silva Freitas, Geiziany Mendes da Silva CESAR . 2016. A Motivational
Study Regarding IoT and Middleware for Health Systems. The Tenth International
Conference on Mobile Ubiquitous Computing, Systems, Services and Technologies

 (Christophe Baland, 2017) Christophe Baland, Damien Cauquil, Thomas Gayet, Julia
Juvigny, Renaud Lifchitz, Nha-Khanh Nguyen. La sécurité de l’Internet des
Objets.Digital Security

 IEEE Wireless Communications and Networking Conference, 2012, pp. 815–819.

 (Xavier,2010),Xavier Besseron. Tolérance aux fautes et reconfiguration dynamique
pour les applications distribuées à grande échelle.Institut National Polytechnique de
Grenoble - INPG, 2010.
 (Zaiter, 2017). Meriem Zaiter. Un mécanisme de tolérance aux fautes pour la sûreté
de fonctionnement d’un système distribué: application au domaine de la domotique
médicale. Thèse de doctorat en science. Laboratoire LIRE. Université de Abdelhamid
Mehri Constantine 2.Algérie.
 (Zeinab Kamal elddin,2017) Zeinab Kamal Aldein Mohammed, Elmustafa Sayed Ali
Ahmed.(2017). Internet of Things Applications, Challenges and Related Future
Technologies. WSN 67(2) 126-148

 (Zilic, 2011) Zeljko Zilic and Katarzyna Radecka. 2011. Fault Tolerant Glucose
Sensor Readout and Recalibration. Wireless Health’11, October 10-13, 2011, San
Diego, USA. ACM 978-1-4503-0982-0.
 Healthcare Devices, Future Generation Computer Systems (2017),
 http://dx.doi.org/10.1016/j.future.2017.04.004
 (Zaiter, 2015) Zaiter, M., Hacini, S., & Boufaida, Z. (2015). An Agent-Based Fault
Tolerance Mechanism for Dependable Medical Systems. International Journal of
Embedded and Real-Time Communication Systems. Vol 6 (1), (pp 47-75).

63