AU: 2022-2023

Examen Classe: 1re GEC

Programmation Orientée Objet en C++

Durée : 1h30
Nombre de pages : 6
Documents : non autorisés

L’internet des objets (Internet of things ”IoT“) fait de nos jours une révolution sur tous les plans de notre
vie quotidienne. Une montre connectée, une voiture connectée, une maison connectée et aussi une
usine connectée, c'est une sélection de cas d’utilisation qui montre que nous sommes de plus en plus
dans un monde d’objets connectés. L’internet des objets “IoT” est devenu une réalité suite à l'évolution
et la maturation d’un ensemble de technologies de télécommunication et de conception des systèmes
embarqués. Les réseaux de capteurs font partie de ces technologies et restent un noyau de base
incontournable dans le cas de mise en œuvre des applications “IoT”.

Le protocole ZigBee, qui se base sur la norme IEEE 802.15.4, est l’une des technologies les plus
utilisées dans le déploiement des réseaux de capteurs. Les modules XBee Pro du fabricant “Digi
International” (figure 1) présentent l’une des solutions disponibles qui implémentent ce protocole. Un
exemple d’utilisation de ces modules est l’industrie 4.0 qui regroupe les bénéfices de la connectivité
des machines et des processus de fabrication avec les bénéfices de l’intelligence artificielle et des
techniques de prise de décision pour aboutir à une industrialisation optimale.

Figure 1: Module XBee Pro

Dans ce cadre, nous proposons d'étudier l'implémentation d’un ensemble de capteurs dans une chaîne
de fabrication de cartes électroniques. Les capteurs utilisés sont connectés à un réseau ZigBee au
moyen des modules XBee Pro.

1/6
Le protocole ZigBee est capable d'être déployé sous une topologie en étoile, en arbre ou en maille.
Dans notre cas, nous avons choisi la topologie maillée (figure 2) qui est une topologie décentralisée et
qui assure un arrangement dynamique du réseau pour s’adapter et se réorganiser de façon à garantir
l’acheminement fiable des informations en optimisant le délai de transmission des données et la
consommation d'énergie.

Cette topologie se base sur trois catégories de nœuds. La première catégorie est celle qui définit le
nœud principal appelé coordinateur (Coordinator). Ce nœud sert à gérer tout le réseau qui lui est
associé et à servir comme interface avec le monde extérieur au réseau. Généralement ce type de
nœud communique avec la passerelle qui fait la liaison avec l'Internet. Le nœud coordinateur sera en
liaison directe ou indirecte avec les différents nœuds de la deuxième catégorie qui s’appelle routeur
(Router) Ces derniers coopèrent entre eux pour organiser le maillage du réseau selon le besoin.
Chaque nœud routeur a la capacité de regrouper autour de lui un ensemble de nœuds terminaux (End
Device) qui constituait la dernière catégorie de nœuds pour un réseau ZigBee. Un nœud terminal
assure la transmission des données depuis les capteurs ou vers les actionneurs qui lui sont
directement rattachés mais ne contribue pas au routage du réseau.

Figure 2: Topologie maillée

Dans notre cas, les différents capteurs qui constituent l’installation sont rattachés à des nœuds
configurés soit en mode routeur soit en mode terminal. En Effet un routeur fait la liaison entre différents
nœuds du réseau mais il peut aussi assurer la fonctionnalité d'un nœud terminal.

Pour mieux organiser et gérer les différents nœuds XBee, nous proposons de développer une
application C++ permettant de modifier et de consulter la configuration de chaque élément. Pour ce
faire nous définissons les différentes catégories d'éléments constituant l'installation par les classes
suivantes (figure 3) qui permettent d’instancier des objets qui représentent le réseau entier.

2/6
 Figure 3: Diagramme des classes

Remarques:
- Le préfixe Set est utilisé pour indiquer qu’il s'agit d’une modification de l’attribut correspondant.
- Le préfixe Get est utilisé pour indiquer qu’il s'agit d’une lecture de l’attribut correspondant.

1. La classe Sensor
Cette classe représente les capteurs de l'installation.
Sensor:
Attributs: (mode “private”)
● Sensor_ID: Identifiant unique pour chaque capteur
● Label: Text indiquant le type de capteur (Ex: “Capteur de température”)
● Value: Valeur de la grandeur physique mesurée
Methodes membres:
● Get_Parameters: Pour récupérer tous les attributs (Utiliser le passage par références)
● Set_Parameters: Pour modifier tous les attributs
● Print: Pour afficher tous les attributs

3/6
2. La classe Base_Class
Base_Class est une super-classe qui sert pour la définition des classes dérivées (héritées) qui
représentent les nœuds de type coordinateur, routeur et terminal.
Base_Class:
Attributs: (mode “protected”)
● Category: Category du nœud (Coordinateur, Routeur ou terminal)
● Address: Adresse physique du nœud
● Network_ID: Identifiant du réseau
Methodes membres:
● GetCategory
● SetCategory
● GetAddress
● SetAddress
● Get_Network_ID
● Set_Network_ID

3. La classe Coordinator_Node
Un nœud coordinateur a le rôle de gérer tout le réseau. Il communique avec les routeurs qui se
présentent dans la liste Retour_Liste. La classe Coordinator_Node est une sous-classe de la classe
Base_Node Base_Class avec un mode d'accès public.
Coordinator_Node:
Attributs: (mode “private”)
● Coordinator_ID: Identifiant unique pour différencier les différents réseaux
● Router_Liste: Pointeur de type Router_Node
● Nbr_Router: Nombre de routeurs dans la liste Router_Liste.
Methodes membres:
● Un constructeur permettant d’initialiser les attributs Coordinator_ID et Nbr_Router par les
valeurs données comme paramètres et puis de réserver dynamiquement la mémoire pour un
tableau d’objets de type Router_Node selon le nombre Nbr_Router. L’adresse de la zone de
mémoire créée est sauvegardée dans le pointeur Router_Liste.
● Un destructeur permettant la libération de la mémoire réservée par le constructeur.
● Get_Coordinator_ID
● Get_Router_Liste
● Get_Nbr_Router
● Add_Router
● Find_Router: Recherche un routeur selon son adresse fournie comme paramètre
● Delete_Router: Supprime un routeur dont l’adresse est fournie comme paramètre
● Print_Network: Affiche tous les nœuds qui constituent le réseau

4/6
4. La classe End_Device_Node
End_Device_Node est héritée de la classe Base_Class avec un mode d'accès public.
End_Device_Node:
Attributs: (mode “protected”)
● Sensor_Liste: Tableau de 5 éléments de type objet Sensor
● Nbr_Sensor: Nombre de capteurs associées à ce routeur (Nombre max = 5)
Methodes membres:
● Get_Sensor_Liste
● Get_Nbr_Sensor
● Add_Sensor
● Find_Sensor
● Delete_Sensor

5. La classe Router_Node
Vue que le nœud routeur comporte les fonctionnalités d’un nœud terminal en plus de sa capacité de
participer au maillage du réseau, nous proposons de créer La classe Router_Node comme une
sous-classe (dérivée) de la classe End_Device_Node avec un mode d'accès public.
Router_Node:
Attributs: (mode “private”)
● Node_Liste: Tableau de type pointeur sur des objets Base_Node Base_Class(10 éléments)
● Nbr_Node: Nombre de nœuds associées à ce nœud routeur (Nombre max = 10)
Methodes membres:
● Get_Node_Liste
● Get_Nbr_Node
● Set_Nbr_Node
● Add_Node
● Find_Node
● Delete_Node
● Print
Travail demandé:
1. Donner la définition des classes Sensor, Base_Class, Coordinator_Node.
Remarque: Pour les méthodes des classes, donner juste les déclarations: Type de retour, nom
de la méthode et liste des paramètres sans développement du code associé. Vous serez invité
à compléter une sélection de ces méthodes dans la question 2.
2. Donner la définition des méthodes suivantes:
Méthodes de la classe Sensor
a. Get_Parameters
b. Set_Parameters
5/6
 c. Print
Méthodes de la classe Coordinator_Node
d. Constructeur
e. Destructeur
f. Get_Router_Liste
3. Donner la fonction principale main() pour réaliser les fonctionnalités suivantes:
a. Demander à l’utilisateur de donner l’identifiant du réseau Coordinateur et le nombre de
nœuds qui sont associés au réseau qui sera représenté par un objet de type
Coordinator_Node.
b. Instancier (déclarer) un objet Main_Coordinator de type Coordinator_Node
c. Initialiser les attributs de Main_Coordinator, hérités de la super-classe, comme suit:
Category: “Coordinator”
Address: Adresse physique du coordinateur, à saisir par l’utilisateur
Network_ID: Identifiant du réseau, à saisir par l’utilisateur
d. Dans une boucle principale, qui se répète tant que l’utilisateur ne demande pas de
quitter, effectuer les tâches suivantes:
i. Appeler la fonction Menu_1() qui affiche le menu principal, donné ci-dessous, et
qui retourne le choix de l’utilisateur (valeur entre 1 et 7 obligatoirement).
1/ Initialiser le Réseau
2/ Ajouter un routeur
3/ Modifier un routeur
4/ Rechercher un routeur
5/ Supprimer un routeur
6/ Afficher le réseau
7/ Quitter

ii. Utiliser une structure de contrôle switch pour assurer la fonctionnalité

sélectionnée par l’utilisateur. Donner l'appel des méthodes adéquates pour
chaque cas. Dans le cas particulier du choix numéro 3 (Modifier un routeur), la
fonction Menu_2() est appelée. Cette fonction donne plus de choix à l’utilisateur
en affichant le menu 2 suivant:
1/ Ajouter un noeud
2/ Modifier un noeud
3/ Supprimer un noeud
4/ Quitter
Les détails et le code de cette fonction ne sont pas demandés dans l’examen.

6/6