RPFE

DEPARTEMENT : GENIE ÉLECTRIQUE
Projet de Fin d’Etudes


Présenté en vue de l’obtention du Diplôme Universitaire de
Technologie en Génie Electrique
Sous le thème
La création d’une machine de classification des pommes avec

l’intelligence artificielle et la supervision à m’aide de la réalité
augmentée
 
Réalisé par : Encadré par :
Titrite OUAICHA
Oussama AK-HAIL Hossine ELIHSSINI
1|Page
Année Universitaire 2021-2022

Dédicaces
Nous dédions ce travail, comme preuve de respect, de gratitude, et de

reconnaissance à :
Nos familles, pour leur soutien, leur affection, et leur amour

inconditionnel.
Notre encadrant Monsieur Hossine ELIHSSINI pour son encadrement et

son assistance.
Madame Fatima Ezzahra NADIR pour ses conseils et son aide précieuse.
Les personnes du département génie électrique qui nous ont aidé à

améliorer nos connaissances.
A tous ceux qui ont attribué de près ou de loin à la réalisation de ce

travail.

2|Page

Remerciements
Nous remercions notre clément Dieu qui nous a donné la puissance pour que nous puissions
terminer ce travail.
Nous tenons tout d’abord à exprimer nos sincères remerciements à Mr. Hossine LIHSSINI pour
sa disponibilité. Monsieur ELIHSSINI nous vous remercions pour votre soutien, sans vous ce
travail n’aurait pas été possible, nous vous sommes sincèrement reconnaissants pour tous vos
efforts.
Et d’autre part nous exprimons nos remerciements à Mme NADIR Fatima Ezzahra pour nous
avoir fait bénéficier de ses compétences et pour son encouragement et son soutien.
Nous souhaitons également faire part de nos remerciements à toute l’équipe pédagogique de
l’école Supérieure de technologie d’Agadir, et les intervenant professionnel responsables de
la formation génie électrique, pour avoir assuré la partie théorique et pratique de cette
dernière.
Enfin, un grand merci à Sanae BARCHA d'être si gentil et si serviable.
Merci à tous et à toutes.

3|Page

Table des matières
Dédicaces : ------------------------------------------------------------------------------------ Erreur ! Signet non défini.

Remerciements : ----------------------------------------------------------------------------- Erreur ! Signet non défini.
Table des matières : ---------------------------------------------------------------------------------------------------------- 4
Liste des figures :-------------------------------------------------------------------------------------------------------------- 6
Liste des tableaux : ----------------------------------------------------------------------------------------------------------- 8
Introduction générale : ------------------------------------------------------------------------------------------------------ 9
Chapitre N°1 : ---------------------------------------------------------------------------------------------------------------- 10
Le Tri :-------------------------------------------------------------------------------------------------------------------------- 10
1.1 Introduction : ------------------------------------------------------------------------------------------------------- 11
1.2 Cahier des charges ------------------------------------------------------------------------------------------------ 11
1.3 La partie software : ------------------------------------------------------------------------------------------------ 11
• L’intelligence artificielle ---------------------------------------------------------------------------------------- 11
• Les sous-ensenbles de L’IA------------------------------------------------------------------------------------- 12
• Programmation --------------------------------------------------------------------------------------------------- 12
o Les bibliothèques utilisées -------------------------------------------------------- 13
o Training -------------------------------------------------------------------------------- 13
o Testing ---------------------------------------------------------------------------------- 14
o Detection------------------------------------------------------------------------------- 14
1.4 La partie software : ------------------------------------------------------------------------------------------------ 15
• Perception du projet -------------------------------------------------------------------------------------------- 15
• Le fonctionnement ---------------------------------------------------------------------------------------------- 15
1.5 Conclusion : --------------------------------------------------------------------------------------------------------- 16
CHAPITRE N°2 : -------------------------------------------------------------------------------------------------------------- 17
La supervision : -------------------------------------------------------------------------------------------------------------- 17

4|Page

2.1 Introduction : ------------------------------------------------------------------------------------------------------ 18

2.2 Cahier des charges : ---------------------------------------------------------------------------------------------- 18
2.3 Unité de traitement : ---------------------------------------------------------------------------------------------- 18
2.4 Modbus TCP/IP : -------------------------------------------------------------------------------------------------- 19
• Trame Modbus --------------------------------------------------------------------------------------------------- 19
o Fonctions ------------------------------------------------------------------------------- 20
2.5 Developpement de l’application :----------------------------------------------------------------------------- 21
• Etape1 : Inscription et téléchargement ------------------------------------------------------------------- 21
• Etape2 : Création de la clef ----------------------------------------------------------------------------------- 22
• Etape3 : Création de la cible ---------------------------------------------------------------------------------- 23
• Etape4 : Création et configuration du projet ------------------------------------------------------------ 25
• Etape5 : Création d’un bouton virtuel --------------------------------------------------------------------- 30
• Etape6 : Transfert de l’application vers le smartphone ----------------------------------------------- 31
2.6 Conclusion : -------------------------------------------------------------------------------------------------------- 32
Chapitre N°3 : ---------------------------------------------------------------------------------------------------------------- 33
La Réalisation :--------------------------------------------------------------------------------------------------------------- 33
3.1 Introduction : ------------------------------------------------------------------------------------------------------- 34
3.2 Le matériel Utilisé------------------------------------------------------------------------------------------------- 34
3.3 Construction de la machine :------------------------------------------------------------------------------------ 36
3.4 L’organigramme de tri: ------------------------------------------------------------------------------------------- 37
3.5 Supervision --------------------------------------------------------------------------------------------------------- 38
3.6 Conclusion : --------------------------------------------------------------------------------------------------------- 38
Conclusion Générale : ----------------------------------------------------------------------------------------------------- 39

5|Page

Listes des figures
Figure1 : les sous-ensembles de L’IA…………………………………………………… Page12

Figure2 : programme de training………………………………………………………. Page13
Figure3 : programme de Testing………………………………………………………. Page14
Figure4 : programme de détection……………………………………………………. Page14
Figure 5 : Perception du projet……………………………………………………….... Page15
Figure6 : pomme fraiche ………………………………………………………………. Page16
Figure7 : trame Modbus TCP/IP………………………………………………………. Page19
Figure8 : installation du vuforia engine package……………………………………… Page22
Figure9 : première étape pour crée une License………………………………………. Page22
Figure10 : création de la clef …………………………………………………………. Page23
Figure11 : image d’un convoyeur………………………………………………………. Page23
Figure12 : clef ………………………………………………………………………… Page24
Figure13 : comment ajouter des cibles………………………………………………… Page24
Figure14 : enregistrer la base de données (les cibles)……………………………… . . Page25
Figure15 : importation du vuforia packag……………………………………………... Page25
Figure16 :la création d’une AR camera……………………………………………...… Page26
Figure17 : coller la clef dans Unity……………………………………………………. Page26
Figure 18 : création d’une image target………………….…………………………… Page27
Figure19 : les cibles importées avec vuforia package………………………..……….. Page27
Figure20: création d’un bouton virtuel………………………………………………… Page28
Figure21 : création d’une plane………………………………………………………. Page28
Figure22 : création d’un script C#............................................................................................. Page29
Figure23 : Schéma bloc représente les étapes à suivre pour transférer l’application AR vers le
smartphone…………………………………………………………………………… Page30
Figure24 : programme c#.......................................................................................................... Page31
Figure25 : Les étape à suivre pour ajouter SDK et JDK…………………………… Page31

6|Page

Figure26 : Les étapes à suivre pour transférer l’application vers le smartphone depuis Unity
…..……………………………………………………………………………………. Page32
Figure27 : Fonctionnement général de notre projet………………………………… Page34
Figure28 : Raspberry pi 4 model B………………………………………………… Page34
Figure 29 : caméra………………………………………………………………… Page35
Figure 30 : Vérin pneumatique simple effet ………………………………………… Page35
Figure 31 : convoyeur ……………………………………………………………… Page35
Figure 32 : capteur infrarouge……………………………………………………… Page35
Figure 33 : carte 16 relais…………………………………………………………… Page35
Figure 34 : schéma bloc montrant la liaison entre tous les composants du projet……. Page36
Figure 35 : organigramme du tri…………………………………………………… Page37
Figure 36 : schéma bloc montrant la communication entre le Raspberry Pi et l’application
……………………………………………………………………………………… Page38

7|Page

Liste des tableaux
Tableau 1 : Les code fonctions…………………………………………………………………………………………………Page22

8|Page

o Introduction générale :
Si on se demande ce que recherchent les entreprises aujourd'hui, ça sera
certainement le profit, et satisfaire leurs clients avec des produits efficaces, aussi
la rapidité de la production. Prenons l’exemple des entreprises qui produisent la
confiture, ils reçoivent des tonnes de fruits chaque jour, et ils ne doivent en choisir
que de bons et frais, le triage de ces fruits doit être rapide et précis pour une
productivité accrue. Ou bien prenons l’exemple d’une chambre à laquelle personne
ne devrait avoir accès sauf une personne, imaginez une petite caméra à côté d’une
porte qui ne s'ouvre qu'à une seule personne ; fascinant n'est-ce pas ? n’oublions
pas ceux qui adorent les animaux, mais ils n’ont pas le temps de les nourrir, une
machine qui fait la distinction entre par exemple un chat et un chien et donne à
chacun sa nourriture sera efficaces pour eux.
Sans doute vous avez déjà entendu parler des robots et des machines qui réalisent
la reconnaissance faciale, la reconnaissance de l’écriture et la distinction entre
plusieurs choses différentes. C’est en fait le sujet le plus tendance actuellement, et
pratiquement le futur.
C’est pour ça qu’on a pensé et réalisé notre projet, nous proposons une machine qui
peux classifier plusieurs choses différentes, facile à utiliser et efficace, avec une
application pour la supervision de la machine.
Ce rapport est organisé autour de trois chapitres :
Le premier chapitre présente c’est quoi l’intelligence artificielle et le model

de classification.
Le deuxième chapitre sera consacré à la description des différentes phases

de réalisation de l’application de supervision sur le logiciel Unity.
Le troisième chapitre contient le matériel utilisé dans notre projet et le
fonctionnement générale de la machine.
Enfin, nous allons terminer notre travail par une conclusion générale.

9|Page

CHAPITRE 1 :
LE TRI

10 | P a g e

1.1 Introduction :
Dans l'industrie, il est difficile de remplacer l'humain par une machine parfois
parce que certaines fonctions ont besoin d'intelligence pour être exécutées, par
exemple triage des choses par couleur ou par type, et si nous voulons donner ces
fonctions à machin, nous devons également lui donner l'intelligence.
1.2 Cahier des charges :

Pour ce projet on a choisi de trier les pommes fraiches et les pommes pourries. Vous
posez les pommes sur un convoyeur, la caméra capte l’image de la pomme et puis
le système identifie le type de la pomme (Fraiche/pourrie) :
• Si la pomme était pourrie un vérin la pousse vers un panier.

• Si elle était fraiche elle termine son chemin.
Du coup notre projet est constitué d’une partie software et d’un autre hardware.
1.3 La partie software :

Pour aboutir à notre objectif, qui est le tri des fruits frais et pourris,
on a réalisé un programme basé sur l’intelligence artificielle, qui fait
les classifications de ces fruits rapidement et précisément.
L’intelligence artificielle :
L’intelligence artificielle consiste à mettre en œuvre un certain nombre
de techniques visant à permettre aux machines d’imiter une forme
d’intelligence réelle. Son but est de permettre à des machines de penser
et d’agir comme des êtres humains.

11 | P a g e

Les sous-ensembles de L’IA :
- Machine Learning : c’est une forme particulière d’intelligence
artificielle, où les machines apprennent à exécuter des tâches pour
lesquelles elles n’ont pas été explicitement programmées.
- Deep Learning : est basée sur une répartition des tâches entre
différents algorithmes de machine Learning, organisés en
différentes couches, chaque couche se base sur la couche
précédente. Ensemble, ces couches constituent un réseau de
neurones artificiel qui imite la manière dont le cerveau humain
résout un problème.
Figure1 : les sous-ensembles de L’IA.
Programmation :
Le programme de classification et divisée en deux parties ; une qui fait le
Training du model et l’autre qui le teste. Tout en commençant par l’importation
des bibliothèques de python, et plusieurs photos des pommes fraiches et d’autres
pourries qui forme notre base de données, puis donner à chaque photo un label
(Fresh Apple, Rotten Apple), ensuite les images se comparent fragment par
fragment, pour trouver les caractéristiques approximatives qui se ressemblent ou
se diffèrent dans deux images différentes et après le model s’enregistre pour qu’il
se teste et pour qu’on s’assure qu’il est fiable et précis
12 | P a g e

o Les bibliothèques utilisées :
- TensorFlow : TensorFlow est une bibliothèque développée par Google
principalement pour les applications du deep Learning.
- OpenCV : OpenCV est une bibliothèque graphique libre, initialement
développée par Intel, spécialisée dans le traitement d'images en
temps réel.
- Keras : Keras, est une bibliothèque en open source. Conçu en langage
Python, le système est exploité dans le domaine du deep Learning.
- Numpy : NumPy est une bibliothèque pour langage de
programmation Python, destinée à manipuler des matrices ou
tableaux multidimensionnels ainsi que des fonctions mathématiques
opérant sur ces tableaux.
o Training :
Figure2 : programme de training.

13 | P a g e

o Testing :
Figure3 : programme de Testing.
o Détection :
Nous avons remarqué que le modèle nous donne toujours deux Output "Fresh"
ou "Rotten" quel que soit les Inputs (clés, voiture, personne), pour résoudre ce
problème, nous avons ajouté une petite partie de la détection afin que notre
modèle ne teste que des pommes
Figure4 : programme de détection
.
14 | P a g e

1.4 La partie hardware :
Pour construire cette machine on avait besoin de :

- Une unité de traitement (Raspberry Pi)
- Caméra
- Actionneurs (convoyeur, vérins)
- Capteurs
Perception du projet :
Figure 5 : Perception du projet.
Le fonctionnement :
La caméra va capter l’image d’une pomme et elle va la traiter si la pomme était
pourrie un vérin la pousse vers un panier si elle était fraiche elle termine son
chemin.

15 | P a g e

1.5 Conclusion
Dans ce chapitre nous avons vu notre projet d’un
point de vue général, aussi comment construire un
modèle de classification basée sur l’intelligence
artificielle programmer avec le langage de
programmation python.
Tout ça commence par un programme de training

puis un programme de test et de détection, pour
finalement avoir un programme fiable, rapide et
précis qui fait la distinction entre une pomme
fraiche et une autre pourrie. Figure6 : pomme fraiche

16 | P a g e

CHAPITRE 2 :
LA SUPERVISION

17 | P a g e

2.1- Introduction :
Comme nous l'avons déjà dit, notre machine doit être facile à contrôler, chaque
employé qui y a accès peut suivre et contrôler la machine, pour cela nous avons
créé une application basée sur la réalité augmentée (a) pour bien superviser la
machine sur une interface simple.
(a) La réalité augmentée :

La réalité augmentée (ou RA) est une technologie qui permet d'intégrer
des éléments virtuels en 3D (en temps réel) au sein d'un environnement
réel.
2.2- Cahier des charges :
Notre objectif est de construire une application de réalité augmentée qui affiche
deux boutons l'un pour démarrer et l'autre pour arrêter, avec des zones de text
indiquant le nombre de pommes pourries et fraîches, notre cahier des charges
comporte les points suivants :
❖ L’application doit être mobile et multipliable.
❖ L’application doit assurer toutes les fonctions de la supervision (Lecture de

mots et de bits, Ecriture de mots et de bits).
❖ Le protocole de communication à utiliser est le Modbus TCP/IP.

2.3- Unité de traitement :
Pour garantir la communication avec l’application de la réalité augmentée
et la commande, notre unité de traitement doit être capable de communiquer
sous protocole Ethernet aussi avec le réseau wifi pour pouvoir la connecter
avec notre application dans le même réseau.
Dans ce projet nous avons choisi le Raspberry Pi puisqu’il contient un port
Ethernet et peut nous assurer la communication avec le réseau wifi.

18 | P a g e

2.4 Modbus TCP/IP :
Modbus est un protocole de communication souvent utilisé pour des réseaux
d'automates programmables. Il fonctionne sur le mode client/serveur.
Pour TCP/IP, elle signifie : « Protocol de contrôle des transmissions/Protocole
Internet ». TCP/IP est un ensemble de règles normalisées permettant aux
ordinateurs de communiquer sur un réseau tel qu'Internet. IP est la partie qui
obtient l'adresse à laquelle les données sont envoyées. TCP est responsable de la
livraison des données une fois que cette adresse IP a été trouvée.
TCP doit établir une connexion avant de transférer des données, car il s'agit d'un
protocole basé sur la connexion. Le client (Le maitre) établit une connexion avec
le Serveur (ou Esclave). Le serveur attend une connexion entrante du client. Une
fois la connexion établie, le serveur répond alors aux requêtes du client jusqu'à ce
que le client ferme la connexion.
Trame Modbus :
Figure9 : trame Modbus TCP/IP

19 | P a g e

Le protocole MODBUS définie un simple PDU (Protocol Data Unit)
indépendant du support de transmission. Le maillage du protocole sur un bus ou
un réseau doit introduire des champs supplémentaires pour constituer l’ADU
(Application Data Unit). C’est le rôle de la couche liaison. Le PDU est construit par
le client qui initie une transaction. Il se compose : D’un code fonction (function
code) et du champ de données (data),
o Fonctions :
Le protocole Modbus propose un certain nombre de fonctions qui

permettent de lire ou d'écrire des données sur le réseau Modbus.
Code Fonction Description
1 Lecture de bits (coils)
2 Lecture de bits d’entrée (discret inputs)
3 Lecture de mots (holding registers)
4 Lecture de mots d’entrée (input registres)
5 Ecriture de 1 bit
6 Ecriture de 1 mot
15 Ecriture de n bits
16 Ecriture de n mots
Tableau 1 : Les code fonctions.

20 | P a g e

2.5- Développement de l’application:
Notre projet a pour but de réaliser une application téléphonique de supervision à
l’aide de la réalité augmenté. Pour y aboutir nous avons utilisé « Unity » comme
éditeur car il est l’un des plus utilisés pour la création des applications et « c# »
comme langage de programmation. Et on a installé « Vuforia » sur Unity pour
pouvoir ajouter des images target, et des objets 3D, aussi elle permet d’activer la
caméra AR sur Unity.
o Unity : Unity est un moteur de jeu multiplateforme développé par Unity

Technologies. Il est l'un des plus répandus dans
l'industrie du jeu vidéo, aussi bien pour les grands
studios que pour les indépendants du fait de sa rapidité
aux prototypages et qu'il permet de sortir les jeux sur
tous les supports.
o Vuforia : Vuforia est un kit de développement logiciel de réalité

augmentée pour les appareils mobiles qui permet la création
d'applications de réalité augmentée. Il utilise la
technologie de vision par ordinateur pour reconnaître
et suivre des images planes et des objets 3D en temps
réel, dans notre cas on a utilisé Vuforia pour ajouter
l’image de la machine à superviser.
Les étapes à suivre pour installer Vuforia engine package :
Etape1 : Inscriptions et téléchargements :

Tout d’abord il faut allez sur le site d’Unity 3d, et téléchargez Unity. Ensuite
allez sur le site de Vuforia engine développer portal https://developer.vuforia.com/
et inscrivez-vous. Connectez-vous et allez sur l’onglet Downloads et téléchargez
l’extension Unity.

21 | P a g e

Figure10 : installation du vuforia engine package.
Etape2 : création de la clef :

Sur vuforia cliquez sur l’onglet Develop et sélectionnez License manager.
Figure11 : premiere etape pour crée une license
Nous allons créer une licence pour notre projet, cliquez sur le bouton Get Basic.

22 | P a g e

Figure12 : création de la clef
Donnez un nom à cette licence puis cliquez sur confirm.
Etape 3 : Création de la cible

Maintenant que nous avons créé une clef, nous pouvons créer une cible. La cible
servira à déclencher la réalité augmentée. Pour moi j’ai choisi cette image pour
cible.
Figure13 : image d’un convoyeur

23 | P a g e

Sur la page License Manager, vous pouvez voir maintenant votre clef, cliquez
dessus. Vous arriverez sur une page comme celle-ci :
Figure14 : clef
Cliquez sur Target Manager pour ajouter des cibles.
Figure15 : comment ajouter des cibles

24 | P a g e

Cliquez sur Add Target, sélectionnez l’option Simple image puis votre image et
mettez par exemple 0.15 en taille. Une fois ces informations remplies, vous
pouvez cliquer sur Add. Une fois que votre image est téléchargée, sélectionnez là
pour la télécharger au format Unity.
Figure16 : enregistrer la base de données (les cibles)
Etape 4 : Création et configuration du projet

Dans le projet Unity 3d que vous allez créer, allez dans Assets et cliquez-droit
puis cliquez sur import Package et sélectionnez le Vuforia package que vous avez
installé intérieurement.
Figure17 : importation du vuforia package

25 | P a g e

Puis supprimer la « main camera » et ajouter le AR camera.
Figure18 :la création d’une AR camera
Double cliquez sur AR camera et Dans l’onglet Vuforia Behaviour, collez votre
licence dans le champ App License Key.
Figure19 : coller la clef dans unity

26 | P a g e

Maintenant, il faut intégrer la cible. Allez dans Assets > Vuforia Engine > image target.
Figure20 : création d’une image target
Double cliquez sur Image Target puis sélectionnez l’image Target que vous avez
téléchargé ultérieurement (pour notre cas c’est PFE > convoyeur).
Figure21 : les cibles importées avec vuforia package

27 | P a g e

Etape 5 : Création d’un bouton virtuel
Cliquez sur advanced puis sur “add virtual button”
Figure22 : création d’un bouton virtuel
Le bouton qu’on a créé est invisible, pour le rendre visible on ajoute un « Plane »
comme le montre l’image dessous.
Figure23 : création d’une plane

28 | P a g e

Et pour donner une fonction à notre bouton, on crée un script en appuyant sur
« add component » dans image target puis sur « new script », ensuite on donne un
nom au script et on clique sur « create and add ».
Figure24 : création d’un script C#

29 | P a g e

Le schéma suivant représente les étapes à suivre pour transférer l’application AR vers le
smartphone.
Figure25 : Schéma bloc représente les étapes à suivre pour transférer l’application AR vers le smartphone.

30 | P a g e

Attention :
Le même nom que vous avez attribué au script il faut l’écrire devant l’expression
« public class » dans le script.
Figure26 : programme c#
Etape 6 : Transfert de l’application vers le smartphone

Après avoir terminé toutes les étapes de création des scènes qui comportent les
objets à superposer à l’environnement réel, nous pouvons télécharger l’application
sur le smartphone. Pour se faire, on commence par ajouter SDK et JDK qui doivent être
déjà téléchargés et installés sur l’ordinateur ; Edit > Prefrences > External Tools > Browse.
Figure27 : : Les étape à suivre pour ajouter SDK et JDK.

31 | P a g e

Ensuite, il faut choisir la plateforme, dans laquelle vous voulez transférer l’application créée
(dans notre cas c’est Android), en allant dans File ,> Build Setting > Android > Swich
Plateform > Add Open Scenes > Build And Run.
Figure28 : Les étapes à suivre pour transférer l’application vers le smartphone depuis Unity.
Enfin, il faut activer du mode Developer sur le smartphone et activer le Débogage USB, qui
permet de transmettre l’application depuis Unity en utilisant un câble USB. Cette opération
nécessite l’installation de l’application Unity Remote à partir de Play Store. Cette application
doit être lancée lors de la transmission de l’application créée depuis Unity.
2.6- Conclusion :
Dans ce chapitre nous avons défini Modbus TCP/IP et nous avons essayé de décrire
clairement toutes les étapes qu’on a fait afin d’atteindre notre objectif qui est la réalisation d’une
application utilisant la réalité augmentée (AR) pour la supervision de notre machine. Ces étapes
commencent par l’installation du logiciel Unity puis l’importation des package, par la création
du bouton virtuel et enfin le transfert de l’application vers le smartphone.

32 | P a g e

CHAPITRE 3 :
LA REALISATION
 33 | P a g e

3.1 Introduction :
Maintenant après avoir terminé la partie de tri et la supervision nous devons relier
ces deux parties. Le schéma bloc suivant représente la logique de fonctionnement
de la machine :
Figure29 : : Fonctionnement général de notre projet
3.2 Le matériel utilisé :

L’unité de traitement :
La classification utilisant l'intelligence artificielle nécessite au moins une RAM
moyenne et un processeur moyen pour travailler sans aucun problème, nous avons
donc besoin d'une unité de traitement capable de gérer tout ce grand nombre de
calculs, pour cela nous avons choisi Raspberry pi 4 pour nombreuses raison telles
que :
-Il coûte moins chère qu’un ordinateur.

-Il est petit et peut être transporté facilement.
-Contient quatre ports USB pour connecter notre
caméra
- Contient un port Ethernet et Peut-être connecter
en wifi.
-Dispose de 40 pins GPIO (entrée / sortie). Figure30: Raspberry pi 4 model B.

34 | P a g e

Camera :
Une webcam qui prend des photos avec une bonne qualité est
nécessaire dans notre projet pour que notre model soit fiable est
précis.
Figure 31 : caméra
Actionneurs :
Vérins : pour les vérins nous avons utilisé un vérin
pneumatique simple effet. L’air comprimé pousse un
piston, ce qui cause le déplacement de la tige, son retour
s'effectuant sous l'action d'un ressort. Un distributeur
à une seule sortie est donc suffisant. Figure 32 : Vérin pneumatique
simple effet
Convoyeur : nous avons utilisé le convoyeur

disponible dans notre école, il est adapté à nos
besoins en raison de sa vitesse moyenne qui est
parfaite pour la détection en vidéo.
Figure 33 : convoyeur
Les capteurs :
Nous avons choisi un capteur infrarouge pour détecter
l'emplacement réel de la pomme sur le convoyeur.
Figure 34 : capteur infrarouge
Relais :
Un relais permet l'ouverture et la fermeture d'un circuit électrique
de puissance à partir d'une information logique. Les deux circuits,
puissance et information, sont complètement isolés nous l'avons
utilisé pour contrôler un distributeur alimenté avec 220V et le
vérin.
Figure 35 : carte 16 relais

35 | P a g e

3.3 La construction de la machine :
Le schéma suivant montre comment nous avons connecté tous les composants
ensemble avec le Raspberry Pi :
Relai
s
Figure 36 : schéma bloc montrant la liaison entre tous les composants du projet
La caméra connectée au port USB, le capteur 1 branché sur le port numéro 16, le
capteur 2 branché sur le port numéro 31, le vérin est commandé par un relais qui
est branché sur le port 15.

36 | P a g e

3.4 L’organigramme de tri :
Figure 37 : organigramme du tri

37 | P a g e

3.5 La supervision :
Pour assurer la communication entre Raspberry et notre application, nous les
avons connectés à un réseau local avec un routeur, après le nombre de pommes
fraîches et pourries et transmis dans deux registres différents via le réseau local
avec Modbus TCP/IP du Raspberry vers notre application, nous avons fait la même
chose avec les boutons virtuels nous avons envoyé deux bits de l’application vers
Raspberry Pi pour démarrer ou arrêter la machine.
Figure 37 : schéma bloc montrant la communication entre le Raspberry Pi et l’application
3.6 Conclusion :
Dans ce chapitre on a vu comment la communication se fait entre le Raspberry Pi
et l’application, et le matériel utilisé pour construire notre machine, en
commençant par le Raspberry Pi, les actionneurs, les capteurs aussi notre interface
virtuelle pour finalement construire une machine complète capable de trier les
pommes fraîches et pourries avec une grande précision, et bien sûr facile à piloter.

38 | P a g e

Conclusion générale
Le travail présenté dans ce rapport de projet de fin d’études se base sur la

réalisation d’une machine capable de classifier les pommes fraiches et les
pommes pourries et d’une application mobile Android pour la supervision de
la machine. D’abord nous avons donné une idée générale sur le
fonctionnement de notre machine, puis nous avons construit un modèle qui
s'entraînait avec 12000 photos de pomme fraîche et pourrie, et on a testé le
modèle avec des photos capturées par une webcam. Après on a ajouté un code
de détection pour que le programme ne teste que les pommes. Ensuite on a
introduit la réalité augmentée avec laquelle on a réalisé une application de
supervision, cette application affiche une interface virtuelle contenant deux
bouton pour piloter le convoyeur et deux zones de texte pour le nombre de
pommes fraiches et pourries ; la communication entre l'application et la
machine se fait avec le protocole Modbus TCP/IP pour envoyer et recevoir les
informations à travers un réseau local. Pour enfin citer les matériels qu’on a
utilisé pour réaliser notre projet.
Finalement nous sommes arrivés à réaliser notre machine même si elle est un
peu lente, aussi que l’application de la réalité augmentée, malgré qu’on à
trouver des difficultés au niveau de la programmation des scripts puisque nous
n’avons pas d’expérience en programmation avec le langage C#.

39 | P a g e

RPFE

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

RPFE

Transféré par

Droits d'auteur :

Formats disponibles

DEPARTEMENT : GENIE ÉLECTRIQUE

Projet de Fin d’Etudes

La création d’une machine de classification des pommes avec

Réalisé par : Encadré par :

Nous dédions ce travail, comme preuve de respect, de gratitude, et de

Nos familles, pour leur soutien, leur affection, et leur amour

Notre encadrant Monsieur Hossine ELIHSSINI pour son encadrement et

Les personnes du département génie électrique qui nous ont aidé à

A tous ceux qui ont attribué de près ou de loin à la réalisation de ce

Enfin, un grand merci à Sanae BARCHA d'être si gentil et si serviable.

Merci à tous et à toutes.

Dédicaces : ------------------------------------------------------------------------------------ Erreur ! Signet non défini.

2.1 Introduction : ------------------------------------------------------------------------------------------------------ 18

Figure1 : les sous-ensembles de L’IA…………………………………………………… Page12

Tableau 1 : Les code fonctions…………………………………………………………………………………………………Page22

Ce rapport est organisé autour de trois chapitres :

Le premier chapitre présente c’est quoi l’intelligence artificielle et le model

Le deuxième chapitre sera consacré à la description des différentes phases

1.2 Cahier des charges :

• Si la pomme était pourrie un vérin la pousse vers un panier.

1.3 La partie software :

Figure1 : les sous-ensembles de L’IA.

Figure2 : programme de training.

Figure3 : programme de Testing.

Figure4 : programme de détection

Pour construire cette machine on avait besoin de :

Figure 5 : Perception du projet.

Tout ça commence par un programme de training

(a) La réalité augmentée :

❖ L’application doit être mobile et multipliable.

❖ L’application doit assurer toutes les fonctions de la supervision (Lecture de

❖ Le protocole de communication à utiliser est le Modbus TCP/IP.

Figure9 : trame Modbus TCP/IP

Le protocole Modbus propose un certain nombre de fonctions qui

Code Fonction Description

1 Lecture de bits (coils)

2 Lecture de bits d’entrée (discret inputs)

3 Lecture de mots (holding registers)

4 Lecture de mots d’entrée (input registres)

o Unity : Unity est un moteur de jeu multiplateforme développé par Unity

o Vuforia : Vuforia est un kit de développement logiciel de réalité

Les étapes à suivre pour installer Vuforia engine package :

Etape1 : Inscriptions et téléchargements :

Figure10 : installation du vuforia engine package.

Etape2 : création de la clef :

Figure11 : premiere etape pour crée une license

Figure12 : création de la clef

Donnez un nom à cette licence puis cliquez sur confirm.

Etape 3 : Création de la cible

Figure13 : image d’un convoyeur

Cliquez sur Target Manager pour ajouter des cibles.

Figure15 : comment ajouter des cibles

Figure16 : enregistrer la base de données (les cibles)

Etape 4 : Création et configuration du projet

Figure17 : importation du vuforia package

Figure18 :la création d’une AR camera

Figure19 : coller la clef dans unity

Figure20 : création d’une image target

Figure21 : les cibles importées avec vuforia package

Figure22 : création d’un bouton virtuel

Figure23 : création d’une plane

Figure24 : création d’un script C#

Etape 6 : Transfert de l’application vers le smartphone