INSTITUT SPECIALISE DE
TECHNOLOGIE APPLIQUEE
INDUSTRIEL BEN M’SIK
2024/2025
Rapport de Projet de Fin
Etude
2ème année
Génie Electrique Option Mécatronique
Réalisé par:
MOUADINE Ayoub Encadré par:
MLIH Reda 2024 _ 2025 M. CHARIKI Ismail
Sommaire
ChapitreI: Composants principaux du Système de parking automatique.......1
Introduction............................................................................................................................... 2
1 La carte de Arduino.................................................................................................................2
1.1 Les types de la carte...................................................................................................2
1.2 Composantes de la carte Arduino UNO :....................................................................5
2 Servo-moteur .................................................................................................................... 7
2.1 Les types de servo-moteur.........................................................................................7
2.2 Composition d’un servo-moteur................................................................................7
2.3 Principe de fonctionnement d’un servo-moteur........................................................8
3 Cristal liquide d'affichage (LCD)..........................................................................................8
4.1 Description de l'écran LCD............................................................................................... 8
4.2 Les points de connexion de l'écran à cristaux..................................................................9
5 Capteur Infrarouge..................................................................................................................9
5.1 Définition......................................................................................................................... 9
5.2 Principe de fonctionnement...........................................................................................10
6 Les matériaux utiliser............................................................................................................11
Conclusion............................................................................................................................... 12
Chapitre II : Simulation........................................................................................................13
Introduction............................................................................................................................. 14
1 Simulation des different circuits............................................................................................14
1.1 Simulateur Isis Proteus Isis.......................................................................................14
1.2 Interface utilisateur..................................................................................................14
1.3 Langage Arduino...................................................................................................... 15
1.3.2 Interface d’utilisateur..................................................................................................15
2 Schéma de parking intelligent..........................................................................................16
2.1 Premier pas : utiliser un servomoteur......................................................................16
Note..................................................................................................................................... 17
2.2 Deuxième pas : utiliser un capteur IR SENSOR.........................................................18
2.3 Troisième pas : utiliser un capteur Afficheur 20x4 I2C.............................................20
2.4 Quatrième pas : simulation du parking intelligent...................................................21
Conclusion............................................................................................................................... 27
Chapitre III : Réalisation...................................................................................................... 28
1 Réalisation du parking intelligent.....................................................................................29
1.1Réalisation de parking intelligent....................................................................................29
Conclusion............................................................................................................................... 31
CONCLUSION GENERALE.............................................................................................................32
Remerciements
Nous souhaitons exprimer nos sincères remerciements à Monsieur
CHARIKI Ismail, notre encadrant, pour son accompagnement, ses
conseils avisés et sa disponibilité tout au long de la réalisation de ce
projet. Son approche pédagogique, basée sur la recherche
personnelle et l'autonomie, nous a permis de renforcer nos
compétences, de développer notre esprit d’initiative et de mener ce
travail avec sérieux et confiance.
Nous remercions également toutes les personnes qui nous ont
soutenus, de près ou de loin, dans la réalisation de ce projet. Que ce
soit par une aide technique, un conseil, ou un simple
encouragement, leur contribution a été précieuse et a fortement
participé à la réussite de notre travail.
Un grand merci à toutes et à tous.
Tu peux intégrer cette version directement dans la section
« Remerciements » de votre rapport de projet.
INTRODUCTION
Le Maroc est confronté à de nombreux défis liés au système traditionnel de
stationnement, où les conducteurs souffrent de divers problèmes, notamment
l’exploitation financière par certains gardiens non réglementés qui imposent des
tarifs arbitraires supérieurs aux prix officiels, ainsi que l'absence de responsabilité
en cas de dommages causés aux véhicules, ces gardiens se dérobant à toute
obligation de protection. Face à ces difficultés, le projet de système de
stationnement automatisé simplifié se présente comme une solution innovante et
efficace, qui restructure entièrement le processus en s’appuyant sur des
technologies intelligentes et accessibles. Ce système repose sur trois composants
principaux : un servomoteur pour contrôler la barrière automatique, des capteurs
infrarouges pour détecter l’entrée et la sortie des véhicules, et un écran LCD pour
afficher les informations de manière claire et directe.
L’un des aspects distinctifs de ce système est qu’il redéfinit le rôle du gardien de
parking, qui passe d’un simple collecteur de paiements à un superviseur d’un
système intelligent. Il est désormais chargé de tâches à forte valeur ajoutée telles
que la surveillance du bon fonctionnement du système, l’assistance aux usagers, la
maintenance régulière, et l’intervention en cas de besoin. Le système fournit
également des données en temps réel sur le nombre de véhicules présents, tout
en affichant des messages de bienvenue qui améliorent l’expérience utilisateur.
Cette transformation intelligente apporte de nombreux avantages pratiques :
amélioration de la précision des comptages et statistiques, transparence des
transactions, réduction de la charge de travail répétitive du gardien, et élévation
de la qualité du service. Elle ouvre également la voie à de futurs développements
comme l’intégration de systèmes de paiement électronique, et la connexion à des
applications mobiles, tout en conservant l’élément humain comme acteur central
dans la gestion et l’exploitation du système
Les solutions technologiques basées sur l’intelligence artificielle (IA) et l’Internet
des objets (IoT) s’imposent comme des alternatives efficaces. Elles permettent la
mise en place de systèmes de paiement automatisés, une surveillance intelligente
par caméras dotées d’IA, ainsi que la construction de parkings couverts
intelligents, protégeant les véhicules des conditions climatiques. Ces systèmes ne
se contentent pas d’offrir un environnement sécurisé et organisé pour le
stationnement, ils constituent également une étape cruciale vers la création de
villes intelligentes et durables. La transition vers des parkings intelligents au Maroc
ne représente pas seulement une amélioration du secteur du stationnement, mais
un véritable saut qualitatif, mettant fin à l’ère de l’extorsion et du manque de
responsabilité, tout en favorisant une culture de transparence et de modernité
dans l’espace publ
ChapitreI:
Composants principaux
du Système de parking
automatique
Page | 1
Introduction
Le choix des matériaux est une tâche fondamentale et très complexe, et pour réussir à bien
l’aborder, on a posé un groupe de critères qu’on devait les satisfaire pour bien réussir notre
choix. Les critères imposés sont les suivants :
• Au niveau de matériau : caractéristiques mécaniques, esthétiques, thermiques, électriques,
économiques, environnementales, physiques.
• Au niveau du procédé : volume, masse, géométrie, taille de la série, caractéristiques
économiques et environnementales.
1 La carte de Arduino
Une carte Arduino est une petite carte électronique équipée d’un microcontrôleur. Le
microcontrôleur permet, à partir d’événements détectés par des capteurs, de programmer et
commander des actionneurs ; la carte Arduino est donc une interface programmable. Elle peut
être programmé pour analyser et produire des signaux électriques, de manière à effectuer des
tâches très diverses comme le contrôle des appareils domestiques, éclairage, chauffage, le
pilotage d’un robot, de l’informatique embarquée, ect
1.1Les types de la carte
La carte Arduino UNO :
C’est la carte idéale pour découvrir l’environnement ARDUINO. Elle permet à tout débutant
de se lancer dans tous ses premiers petits projets. Comme c’est la carte la plus utilisée, il est
très facile de se référer aux tutoriels très nombreux sur le net et ainsi de ne pas rester seul
dans son exploration. Sa simplicité devient par contre un handicap lorsqu’il s’agit de
multiplier les périphériques, de manipuler des algorithmes lourds ou d’interagie avec les
OS / Android pour lesquels d’autres cartes Arduino sont plus adaptées.
Page | 2
La carte Arduino LEONARDO :
C’est la carte qui est prévue pour succéder à la carte Arduino UNO en présentant des
caractéristiques équivalentes mais une ergonomie revue et une stabilité plus éprouvée. Sa
diffusion moins importante limite le support utilisateur disponible sur le net.
La carte Arduino Mega :
La carte Arduino Mega est la carte la plus diffusée après la carte Arduino UNO. Elle offre un
nombre d’entrées/sorties beaucoup plus important (54 contre 14), un processeur plus
puissant doté d’une mémoire plus vaste qui permet d’exploiter des algorithmes plus
complexes.
Page | 3
La carte Arduino Mega ADK :
La carte Arduino Mega ADK offre les mêmes caractéristiques techniques que la carte Arduino
Mega mais son port USB permet de la connecter avec un environnement androïde ouvrant de
nouvelles perspectives d’interaction avec le monde des Smartphones et des capteurs dont ils
sont dotés. Sa mise en œuvre nécessite par contre de solides connaissances en Java et la
capacité à développer ses propres applications.
La carte Arduino Due :
La carte Arduino Due est une évolution de la carte Arduino Mega et offre des
performances réputées 3 fois supérieures. Elle permet de manipuler rapidement des
algorithmes lourds particulièrement utiles dans le monde de la robotique par exemple.
Page | 4
La carte Arduino Nano :
La carte Arduino nano n’est ni plus ni moins qu’une carte Arduino UNO miniaturisée. Sa taille et
son poids réduits la destinent à une utilisation dans des espaces réduits (en textile par exemple)
ou dans des applications de robotique ou de modélisme pour lesquels le poids et la taille sont
des facteurs déterminant ( hélicoptères, drones…).
La carte Arduino Yun :
La carte Arduino Yun, récemment proposée par Arduino, est conçue pour contrer les avantages
de la carte Raspberry. Elle est un dérivé de la carte Leonardo et a pour objectif de combiner la
puissance de Linux avec la facilité d’utilisation d’une carte Arduino. Elle est également la
première carte Arduino à être dotée nativement d’un wifi intégré.
1.2Composantes de la carte Arduino UNO :
Une carte Arduino UNO se compose essentiellement de :
Prise jack : permet de brancher une alimentation (pile, batterie, adaptateur Secteur, + au
centre Vin 7 à12 V
Page | 5
Microcontrôleur : stocke le programme et l’exécute.
Entrées et analogique : Permet de brancher des capteurs et des détecteur analogiques.
Connexion USB (Universal Serial Bus) : Permet d’alimenter la carte en Énergie électrique (5V).
Permet de téléverser le programme dans la carte.
Entrées et sorties numériques (Digital) : Permet de brancher des actionneurs. Permet de b
rancher des détecteurs.
Page | 6
2 Servo-moteur .
Un servo-moteur est un type de moteur électrique. C’est un dispositif typiquement utilisé
en modélisme pour, par exemple, contrôler la direction d’une voiture télécommandée. Sur
un servo-moteur, l‘angle de l’axe reste fixé dans une position et peu varier entre 0 et 180° en
fonction du signal envoyé
2.1Les types de servo-moteur
Il existe divers types de servomoteur, de taille, poids et couple (force) diffé[Link]
photographie ci-dessous présente un servomoteur très classique en modélisme : le futuba
S3003. Un peu plus bas l’article, on utilisera un autre servomoteur, communément appelé
"servomoteur 9 grammes", par souci de consommation électrique
2.2Composition d’un servo-moteur
Le servomoteur est composé de plusieurs éléments visibles et invisible :
Un moteur à courant continu
Des engrenages pour former un réducteur (en plastique on en métal)
Un capteur de position de l’angle d’orientation de l’axe (un potentiomètre)
Une carte électronique pour le contrôle de la position de l’axe et le pilotage du moteur à
courant continu
Les fils, qui sont au nombre de trois
L’axe de rotation sur lequel est monté un accessoire en plastique ou en métal
Le boitier que le protège
Page | 7
2.3Principe de fonctionnement d’un servo-moteur
La plupart des servomoteurs sont commandés par l’intermédiaire d’un câble électrique à
trois fils qui permet d’alimenter le moteur et de lui transmettre des consignes de position
sous forme d’un signal codé en largeur d’impulsion plus communément appelé PWM. Cela
signifie que c’est la durée des impulsions qui détermine l’angle absolu de l’axe de sortie et
donc la position du bras de commande du servomoteur. Le signal est répété
périodiquement, en général toutes les 20 millisecondes, ce qui permet à l’électronique de
contrôler et de corriger continuellement la position angulaire de l’axe de sortie, cette
dernière étant mesurée par le potentiomètre.
3 Cristal liquide d'affichage (LCD)
4.1 Description de l'écran LCD
Ce type d'écran est le mois et le plus commun parmi les passionnés d'électronique et les projets
électroniques, car ils sont disponibles à bas prix et faciles à programmer, et ce type est
disponible en différentes tailles et couleurs, avec 20x4 et les mois entre eux. 16×2, 20×2 et
Page | 8
autres. Nous entendons par 20×4, c'est-à-dire, il y a quatre lignes et chaque ligne peut être
écrite 20 caractères
4.2 Les points de connexion de l'écran à cristaux
Les points de connexion de l'écran à cristaux Sélection de l'enregistreur 1-RS : Ce port nous
détermine dans quelle mémoire nous écrivons des données ! L'enregistreur de données ou
l'enregistreur d'instructions est sélectionné Option 2-R / W pour lire ou écrire, ce port spécifie
soit sélectionner le mode lecture ou écriture. 3-enable pin Ce port, s'il est activé, vous permet
d'écrire sur l'écran LCD broche de données 4- (D0-D7) : ce sont les ports par lesquels nous
transmettons des données aux enregistreurs.
4.3 Écran à cristaux liquides 20 * 4 avec système de connexion I2C
Il est caractérisé par l'utilisation du système I2C opération et contrôle à travers deux fils
seulement, ce qui est une énorme provision pour les prises du panneau de contrôle utilisé dans
notre projet et facilite le processus de connexion et de fonctionnement.
5 Capteur Infrarouge
5.1 Définition
Le capteur d'évitement d'obstacles à capteur infrarouge IR est une solution peu coûteuse pour
la détection d'évitement pour la robotique, la voiture intelligente et d'autres utilisations
Page | 9
électroniques. Dans cette leçon, nous allons vous montrer comment fonctionne le capteur
d'évitement d'obstacles et comment l'utiliser avec la carte ARDUINO UNO.
Le capteur infrarouge ou le capteur IR a deux parties principales. Émetteur IR et récepteur IR. La
responsabilité de l'émetteur IR ou de l'émetteur infrarouge est la transmission des ondes
infrarouges tandis que le travail du récepteur IR est de recevoir ces ondes infrarouges. Le
récepteur IR envoie constamment des données numériques sous la forme de 0 (LOW) ou 1
(HIGH) à la broche V out du capteur.
5.2 Principe de fonctionnement
Page | 10
L'émetteur infrarouge envoie un signal infrarouge qui, en cas de surface réfléchissante (par
exemple de couleur blanche), rebondit dans certaines directions, y compris celle du récepteur
infrarouge qui capte le signal détectant l'objet.
Lorsque la surface est absorbante (par exemple de couleur noire), le signal IR n'est pas réfléchi
et l'objet ne peut pas être détecté par le capteur. Ce résultat se produirait même si l'objet est
absent.
5.3 Caractéristiques Techniques
Voltage de fonctionnement : DC 3,3 V-5 V
Intensité du courant ≥ 20mA
Température de fonctionnement : －10 ℃ --> ＋ 50 ℃
Plage de distance : 2-40 cm
Interface IO : interface 4 fils (GND / Vcc / OUT / EN)
Signal de sortie : tension TTL
Mode d'hébergement : régulation de résistance multi-cercle
Angle effectif : 35 °
Taille : 41,7 * 16,7 mm
Poids : 5g
6 Les matériaux utiliser
La réalisation d’un système de parking automatique peut faire appel à différents types de cartes
Arduino, de servomoteurs et d’écrans LCD, en fonction de la complexité du projet, de sa taille,
mais aussi des moyens financiers disponibles et des exigences techniques. Plus le projet est
Page | 11
avancé, plus il nécessite des composants sophistiqués, comme des capteurs de distance, des
modules de communication sans fil (Bluetooth, Wi-Fi) ou même des caméras. Cependant, selon
ma vision du projet, qui vise à illustrer le principe de base d’un parking automatique simple, et
en tenant compte du coût des composants, j’ai choisi d’utiliser des éléments suffisants et
adaptés pour un système fonctionnel sans surcoût inutile.
Ainsi, les composants que j’ai sélectionnés sont les suivants :
Un écran LCD 20x4 avec interface I2C, permettant d’afficher clairement des informations sur
quatre lignes, comme l’état du parking ou des messages d’orientation.
Des capteurs infrarouges (IR), pour détecter la présence des voitures aussi bien aux
entrées/sorties que dans les emplacements de stationnement.
Un servomoteur de type SG90 ou Futuba S3003, destiné à l’ouverture et à la fermeture
automatique des barrières.
Une carte Arduino UNO R3, qui agit comme le centre de contrôle du système en traitant les
signaux des capteurs et en commandant les actionneurs et l’afficheur.
Ces composants représentent un choix judicieux et équilibré pour construire un prototype de
parking intelligent simple, pédagogique et fonctionnel, tout en restant
accessible et économique.
Conclusion
Le choix des matériaux était la phase la plus délicate dans notre projet. En effet, il ne portait pas
seulement sur un aspect purement technique répondant à des exigences fonctionnelles, mais
aussi à des attentes relevant des préférences des utilisateurs dans le cadre d’un marché
spécifique. En gros, le choix des matériaux a été analysé sous l’angle de l’ingénierie des
matériaux, du temps de réponse, sans oublier enfin le côté esthétique (le design industri
Page | 12
Chapitre II :
Simulation
Page | 13
Introduction
Notre simulation de parking intelligent était avant l'avant-dernière tâche que nous devions faire,
les études étaient déjà terminées et les matériaux étaient déjà en place, il ne manquait plus
qu'une structure pour accueillir ces appareils puis vérifier si les mesures que nous avions faites
concilieraient les côtés techniques avec le côté esthétique.
1 Simulation des different circuits
1.1Simulateur Isis Proteus Isis
Proteus est une suite logicielle destinée à l'électronique. Développé par la société Labcenter
Electronics, elle est principalement connue pour éditer des schémas électriques. Par ailleurs
le logiciel permet également de simuler ces schémas.
Les circuits électriques conçus grâce à ce logiciel peuvent être utilisé dans des
documentations car le logiciel permet de contrôler la majorité de l'aspect graphique des
circuits.
1.2Interface utilisateur
Page | 14
1.3Langage Arduino
1.3.1 Définition
Le langage Arduino est inspiré de plusieurs langages. On retrouve notamment des
similarités avec le C, le C++. Le langage impose une structure particulière typique de
l’informatique embarquée. La programmation ce fait de manière séquentielle c’est-à-
dire une suite d’instruction élémentaires
1.3.2 Interface d’utilisateur
Page | 15
Le cadre numéro 1 : ce sont les options de configuration du logiciel
Le cadre numéro 2 : il contient les boutons qui vont nous servir lorsque l'on va programmer nos
cartes
Le cadre numéro 3 : ce bloc va contenir le programme que nous allons créer
Le cadre numéro 4 : celui-ci est important, car il va nous aider à corriger les fautes dans notre
programme C'est le débogueur.
Un programme (ou "sketch") Arduino est constitué de 2 fonctions distinctes :
La fonction de configuration "void setup" exécutée une seule fois au lancement du
Programme.
On appelle aussi cette fonction : fonction d’initialisation.
La fonction "void loop" qui est ensuite exécutée indéfiniment en boucle
2 Schéma de parking intelligent
2.1Premier pas : utiliser un servomoteur
Afin de bien maitriser la programmation et l’utilisation de la carte Arduino, On va tout
d’abord commencer par des programmes simples dont le but est de réaliser un programme
optimal pour notre parking intelligent. Commençons au début par un programme assez
simple, dans lequel on cherche à sert à Faire tourner le bras du servo moteur
Page | 16
Le code Arduino utilisé :
//mettre l’angle du bras de votre servomoteur à 90°
#include <Servo.h>
monServo; // création d'un nouveau servomoteur
void setup() {
[Link] (6, 100) ;
[Link] (90) ;
[Link] (7) ;
[Link] (90) ; }
void loop() {
}
Note
Ce programme écrit en langage Arduino a pour objectif de positionner les bras de deux
servomoteurs à un angle de 90°, ce qui correspond à la position centrale. Il commence par
inclure la bibliothèque Servo.h, nécessaire pour contrôler les servomoteurs, puis crée deux
objets servo1 et servo2 représentant les deux moteurs. Dans la fonction setup(), exécutée
une seule fois au démarrage, chaque servomoteur est attaché à une broche numérique de la
carte Arduino (la broche 6 pour servo1 et la broche 7 pour servo2), puis un signal est envoyé
à chacun pour qu’il se place à 90°. La fonction loop() est vide, ce qui signifie qu’aucune
action répétée n’est prévue après l’initialisation. Ce code est souvent utilisé pour calibrer les
moteurs avant de leur faire exécuter des mouvements plus complexes.
Page | 17
2.2Deuxième pas : utiliser un capteur IR SENSOR
Afin de mettre en évidence le fonctionnement du 4 capteur IR SENSOR 2 d’entré et 2 de
sorté et 4 capteur de place station, on réalise la simulation suivante, on relie les capteurs a
la carte Arduino on va lire les résultats indiqués par le capteur
#define ENTRANCE_IR1 2
#define ENTRANCE_IR2 0
#define EXIT_IR1 3
#define EXIT_IR2 1
#define PARKING_1 10
#define PARKING_2 11
#define PARKING_3 12
#define PARKING_4 13
bool parkingSpots[4] = {false, false, false, false};
bool entranceGateOpen = false;
bool exitGateOpen = false;
void setup() {
pinMode(ENTRANCE_IR1, INPUT);
pinMode(ENTRANCE_IR2, INPUT);
Page | 18
pinMode(EXIT_IR1, INPUT);
pinMode(EXIT_IR2, INPUT);
pinMode(PARKING_1, INPUT);
pinMode(PARKING_2, INPUT);
pinMode(PARKING_3, INPUT);
pinMode(PARKING_4, INPUT);
void loop() {
updateParkingSpots();
handleEntrance();
handleExit();
void updateParkingSpots() {
parkingSpots[0] = digitalRead(PARKING_1);
parkingSpots[1] = digitalRead(PARKING_2);
parkingSpots[2] = digitalRead(PARKING_3);
parkingSpots[3] = digitalRead(PARKING_4);
}
void handleEntrance() {
if (!entranceGateOpen && digitalRead(ENTRANCE_IR1) && !isParkingFull()) {
openEntranceGate();
}
if (entranceGateOpen && digitalRead(ENTRANCE_IR2)) {
closeEntranceGate();
}
}
void handleExit() {
if (!exitGateOpen && digitalRead(EXIT_IR1)) {
openExitGate();
}
if (exitGateOpen && digitalRead(EXIT_IR2)) {
closeExitGate();
}
Page | 19
}
Ce programme est conçu pour gérer automatiquement les barrières d’entrée et de sortie d’un
parking, tout en surveillant l’état des places de stationnement à l’aide de capteurs infrarouges
(IR). Il commence par la définition des broches reliées aux capteurs d’entrée et de sortie, ainsi
qu’à quatre capteurs représentant les emplacements de stationnement (PARKING_1 à
PARKING_4). Dans la fonction setup(), toutes ces broches sont configurées comme entrées. Une
variable tableau parkingSpots est utilisée pour stocker l’état de chaque place (occupée ou libre).
La boucle principale loop() exécute en continu trois fonctions : updateParkingSpots() pour
mettre à jour l’état des places, handleEntrance() pour gérer l’ouverture et la fermeture de la
barrière d’entrée, et handleExit() pour celle de la sortie. Lorsque le capteur d’entrée détecte une
voiture et qu’au moins une place est disponible, la barrière d’entrée s’ouvre automatiquement.
Une fois la voiture passée, elle se referme. Le même principe s’applique à la sortie. Ce
programme permet donc d’organiser efficacement le flux des véhicules et d’empêcher l’accès si
le parking est complet.
2.3Troisième pas : utiliser un capteur Afficheur 20x4 I2C
Tout d’abord, vous devez souder la carte d’adaptation I2C (piggy-back) au module LCD à 16
broches. Assurez-vous que les broches de la carte I2C sont bien droites et s’insèrent
correctement dans le module LCD, puis soudez la première broche tout en maintenant la
carte I2C bien alignée dans le même plan que le module LCD. Une fois la soudure terminée,
prenez quatre fils de connexion (jumper wires) et reliez le module LCD à votre carte
Arduino.
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
[Link]();
[Link]();
[Link]();
Page | 20
[Link](0, 0);
[Link]("Welcome");
[Link](0, 1);
if (isParkingFull()) {
[Link]("A fullplace");
} else {
[Link]("ENTER");
}
[Link](0, 3);
[Link]("P1:");
[Link](parkingSpots[0] ? "1" : "0");
[Link](" P2:");
[Link](parkingSpots[1] ? "1" : "0");
[Link](" P3:");
[Link](parkingSpots[2] ? "1" : "0");
[Link](" P4:");
[Link](parkingSpots[3] ? "1" : "0");
}
Cette partie du programme est chargée d’afficher les informations du parking sur un écran LCD
utilisant le protocole I2C. Tout d’abord, la bibliothèque LiquidCrystal_I2C est incluse, puis l’écran
est initialisé avec l’adresse 0x27 et un format de 20 colonnes sur 4 lignes. Ensuite, le
rétroéclairage est activé, l’écran est effacé, et le message « Welcome » s’affiche sur la première
ligne. Sur la deuxième ligne, le programme vérifie si le parking est plein grâce à la fonction
isParkingFull(). Si c’est le cas, le message « A fullplace » est affiché, sinon le mot « ENTER »
s’affiche pour indiquer qu’une place est disponible. Enfin, sur la quatrième ligne, l’état de
chaque place de stationnement (P1 à P4) est affiché : un « 1 » signifie que la place est occupée,
tandis qu’un « 0 » indique qu’elle est libre. Cet affichage offre une interface simple et claire pour
informer en temps réel de la disponibilité des places dans le parking.
2.4Quatrième pas : simulation du parking intelligent
Après avoir étudié séparément et choisi minutieusement les composants contribuant dans
la construction de notre parking intelligent, on les a assimilés tous ensemble et voilà ce
qu’on a obtenu :
Schéma électrique du parking intelligent
Page | 21
#include <Servo.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define ENTRANCE_IR1 2
#define ENTRANCE_IR2 0
#define EXIT_IR1 3
#define EXIT_IR2 1
#define PARKING_1 10
#define PARKING_2 11
#define PARKING_3 12
#define PARKING_4 13
#define ENTRANCE_SERVO 6
#define EXIT_SERVO 7
LiquidCrystal_I2C lcd(0x27, 20, 4); // عنوانI2C 0x27، 20 شاشةx4
Servo entranceServo;
Page | 22
Servo exitServo;
bool parkingSpots[4] = {false, false, false, false};
bool entranceGateOpen = false;
bool exitGateOpen = false;
void setup() {
pinMode(ENTRANCE_IR1, INPUT);
pinMode(ENTRANCE_IR2, INPUT);
pinMode(EXIT_IR1, INPUT);
pinMode(EXIT_IR2, INPUT);
pinMode(PARKING_1, INPUT);
pinMode(PARKING_2, INPUT);
pinMode(PARKING_3, INPUT);
pinMode(PARKING_4, INPUT);
[Link](ENTRANCE_SERVO);
[Link](EXIT_SERVO);
closeEntranceGate();
closeExitGate();
[Link]();
[Link]();
[Link]();
Page | 23
updateDisplay();
void loop() {
updateParkingSpots();
handleEntrance();
handleExit();
updateDisplay();
delay(100);
void updateParkingSpots() {
parkingSpots[0] = digitalRead(PARKING_1);
parkingSpots[1] = digitalRead(PARKING_2);
parkingSpots[2] = digitalRead(PARKING_3);
parkingSpots[3] = digitalRead(PARKING_4);
void handleEntrance() {
if (!entranceGateOpen && digitalRead(ENTRANCE_IR1) && !isParkingFull()) {
openEntranceGate();
Page | 24
}
if (entranceGateOpen && digitalRead(ENTRANCE_IR2)) {
closeEntranceGate();
void handleExit() {
if (!exitGateOpen && digitalRead(EXIT_IR1)) {
openExitGate();
if (exitGateOpen && digitalRead(EXIT_IR2)) {
closeExitGate();
bool isParkingFull() {
for (int i = 0; i < 4; i++) {
if (!parkingSpots[i]) return false;
return true;
void openEntranceGate() {
[Link](90);
Page | 25
entranceGateOpen = true;
void closeEntranceGate() {
[Link](0);
entranceGateOpen = false;
void openExitGate() {
[Link](90);
exitGateOpen = true;
void closeExitGate() {
[Link](0);
exitGateOpen = false;
void updateDisplay() {
[Link]();
[Link](0, 0);
[Link]("Welcome");
[Link](0, 1);
if (isParkingFull()) {
Page | 26
[Link]("A fullplace");
} else {
[Link]("ENTER");
[Link](0, 3);
[Link]("P1:");
[Link](parkingSpots[0] ? "1" : "0");
[Link](" P2:");
[Link](parkingSpots[1] ? "1" : "0");
[Link](" P3:");
[Link](parkingSpots[2] ? "1" : "0");
[Link](" P4:");
[Link](parkingSpots[3] ? "1" : "0");
Conclusion
Dans ce chapitre, nous avons cité en détail les différentes étapes d’un schéma bloc du circuit de
Maquette d'un parking avec barrière automatique. Notre objectif dans cette partie de ce travail
était de réaliser tous les composants de notre projet c’est-à-dire le servomoteur avec le lisse,
l'écran LCD et les différents capteurs. Ensuite, la connexion et programmation les composants
principaux avec le microcontrôleur Arduino ; dans laquelle nous avons tester l'entrée et sorti
des véhicules compter et décompter les nombres des véhicules avec afficher le tous les
séquences dans l'écran.
Page | 27
Chapitre III :
Réalisation
Page | 28
1 Réalisation du parking intelligent.
1.1Réalisation de parking intelligent
La réalisation de notre projet qui donne les images suivant :
Page | 29
Page | 30
Conclusion
Ce projet de fin d’étude nous a permis de mettre en application les différentes connaissances
théoriques acquises durant notre formation en réalité.
Page | 31
CONCLUSION GENERALE
Le système de parking automatique basé sur Arduino et capteurs infrarouges, avec
affichage sur écran LCD I2C, représente une solution intelligente et efficace pour la
gestion des places de stationnement. Grâce à l’automatisation des barrières
d’entrée et de sortie, ainsi qu’à la détection en temps réel de l’occupation des
places, ce projet permet d’optimiser l’organisation du trafic à l’intérieur d’un
parking tout en améliorant l’expérience des utilisateurs. De plus, l’utilisation d’un
affichage clair permet aux conducteurs de savoir immédiatement si des places
sont disponibles ou non. En résumé, ce système allie technologie simple et utilité
pratique, ce qui en fait une excellente base pour des projets domotiques ou des
applications réelles à petite échelle.
Le premier chapitre : traite des généralités sur l’ARDUINO et les servomoteurs. Ces
deux composants sont très importants dans le domaine de la microélectronique
et les systèmes embarquées et automatiques. L’ARDUINO et les servomoteurs
peuvent être utilisés dans des dizaines d'applications liées à cette technologie.
Pour cette raison, Nous avons représenté les différents types de ces composants
ainsi que le mécanisme de fonctionnement de chacun d’eux.
Aux deuxièmes chapitres : Méthode de connexion et programmation des
composants principaux avec le Arduino ; dans laquelle nous avons réalisé le
système globale (Tester l'entrée et sorti des véhicules, monte et descend la lisse,
compter et décompter les nombres des véhicules avec afficher le tous les
séquences dans L’écran).
Aux troisièmes chapitre : nous avons réalisé une application de parking intelligent
qui utilise ces composants électroniques, sans oublier de donner le câblage et
codage utilisés dans cette manipulation.
Page | 32
