Ministère de L’enseignement Supérieur et de République du Mali
La Recherche Scientifique Un peuple-un but-une foi
************************************
******************
Master énergie renouvelable et environnement M1S2
LISTE DES MEMBRES DU GROUPE2 :
NOMS PRENOMS
COULIBALY Abdoulaye
MACALOU Moussa
DIARRA Drissa
DIALLO Amadou Lamarana
DEMBELE Fatoumata
APPRECIATION :
DATE :
21/01/2026
Dr Abdoulaye BAYOKO
0
REMERCIEMENTS
La réalisation de ce mini-projet s’inscrit dans le cadre de la formation en automatisme et
systèmes programmables. À ce titre, nous tenons à exprimer notre sincère gratitude envers
l’ensemble des enseignants qui assurent la transmission des connaissances théoriques et
pratiques dans ce domaine. La qualité de l’encadrement pédagogique, la rigueur
méthodologique ainsi que les orientations techniques fournies ont constitué une base
essentielle pour mener à bien cette étude.
Nos remerciements s’adressent également à l’administration et aux responsables de l’École
Nationale d’Ingénieurs Abderrahmane Baba Touré pour les moyens techniques, matériels et
académiques mis à la disposition des étudiants dans le cadre des travaux pratiques et des
projets d’application.
Nous remercions aussi mes camarades de promotion pour les échanges techniques, les
discussions constructives et l’entraide qui ont contribué à améliorer la compréhension des
aspects pratiques liés à la commande des systèmes automatisés.
Enfin, nous témoignons notre reconnaissance à toute personne ayant apporté un soutien, une
suggestion ou une aide technique ayant participé, de près ou de loin, à l’aboutissement de ce
travail.
1
DÉDICACE
Nous dédions ce travail à ma famille pour son soutien constant tout au long de mon parcours
académique.
Nous le dédions également à tous les étudiants en ingénierie qui s’intéressent aux systèmes
automatisés, à la programmation embarquée et aux technologies de commande industrielle,
domaines clés du développement technologique moderne.
2
RÉSUMÉ
Le présent mini-projet traite de la modélisation et de la simulation du fonctionnement d’un
ascenseur à l’aide d’une carte Arduino utilisée comme automate programmable pédagogique.
L’objectif principal consiste à reproduire la logique de commande d’un système de transport
vertical multi-niveaux en utilisant des entrées numériques (boutons poussoirs) et des sorties
lumineuses (LED) représentant les états de fonctionnement.
L’étude débute par une analyse des principes généraux de fonctionnement des ascenseurs et
des architectures de commande associées. Une modélisation fonctionnelle du système est
ensuite réalisée afin d’identifier les séquences d’opération, les transitions d’état et les
conditions de commande. Cette modélisation est traduite sous forme de logique séquentielle
inspirée du GRAFCET.
La mise en œuvre pratique repose sur la plateforme Arduino, qui joue le rôle d’un automate
programmable simplifié. Le système comprend des dispositifs d’entrée simulant les appels
d’étage et des indicateurs lumineux matérialisant la position et le mouvement de la cabine. La
programmation, le câblage et les tests de validation permettent de vérifier la cohérence du
modèle de commande proposé.
Les résultats obtenus montrent qu’une carte microcontrôleur peut être utilisée efficacement
pour illustrer les principes fondamentaux de la commande séquentielle d’un système
automatisé de type ascenseur.
3
ABSTRACT
This mini-project focuses on the modeling and simulation of an elevator control system using
an Arduino board acting as an educational programmable controller. The main objective is to
reproduce the control logic of a multi-level vertical transport system using digital inputs (push
buttons) and LED indicators representing system states.
The study begins with an overview of elevator operating principles and control architectures.
A functional model is then developed to identify operating sequences, state transitions, and
control conditions. This model is translated into a sequential logic inspired by GRAFCET
methodology.
The practical implementation uses an Arduino platform as a simplified controller. Input
devices simulate floor requests while LEDs represent cabin position and movement status.
Programming, wiring, and validation tests are carried out to verify the consistency of the
proposed control logic.
The obtained results demonstrate that a microcontroller platform can effectively be used to
simulate and teach the fundamentals of automated elevator control systems.
4
LISTE DES ABRÉVIATIONS
API — Automate Programmable Industriel
E/S — Entrées / Sorties
LED — Diode Électroluminescente
IDE — Environnement de Développement Intégré
GRAFCET — Graphe Fonctionnel de Commande Étapes/Transitions
BP — Bouton Poussoir
RDC — Rez-de-chaussée
MCU — Microcontrôleur
TOR — Tout Ou Rien
5
Table des matières
REMERCIEMENTS .................................................................................................................. 1
DÉDICACE ................................................................................................................................ 2
RÉSUMÉ .................................................................................................................................... 3
ABSTRACT ............................................................................................................................... 4
LISTE DES ABRÉVIATIONS .................................................................................................. 5
INTRODUCTION GÉNÉRALE................................................................................................ 9
Contexte ................................................................................................................................. 9
Problématique......................................................................................................................... 9
Objectifs du projet .................................................................................................................. 9
Méthodologie ....................................................................................................................... 10
Organisation du rapport ........................................................................................................ 10
CHAPITRE I — GÉNÉRALITÉS SUR LES ASCENSEURS ............................................... 11
I.1 Introduction ..................................................................................................................... 11
I.2 Définition d’un ascenseur ............................................................................................... 11
I.3 Historique et évolution .................................................................................................... 12
I.4 Catégories d’ascenseurs .................................................................................................. 13
a. Selon le mécanisme d’entraînement ......................................................................... 13
b. Selon l’usage ............................................................................................................ 13
c. Selon la vitesse ......................................................................................................... 13
I.5 Ascenseurs hydrauliques ................................................................................................. 14
Caractéristiques : .............................................................................................................. 14
Avantages : ....................................................................................................................... 14
Inconvénients : ................................................................................................................. 14
I.6 Ascenseurs à traction à câble .......................................................................................... 15
Caractéristiques : .............................................................................................................. 15
Variantes : ........................................................................................................................ 16
I.7 Structure mécanique d’un ascenseur ............................................................................... 16
a. Cabine....................................................................................................................... 16
b. Rails de guidage ....................................................................................................... 16
c. Contrepoids .............................................................................................................. 17
d. Système d’entraînement ........................................................................................... 17
e. Portes ........................................................................................................................ 17
f. Dispositifs de sécurité .............................................................................................. 17
6
I.8 Principe général de fonctionnement................................................................................ 18
I.9 Critères de choix d’un type d’ascenseur ......................................................................... 19
I.10 Domaines d’application ................................................................................................ 19
I.11 Conclusion .................................................................................................................... 20
CHAPITRE II — AUTOMATE PROGRAMMABLE ET CARTE ARDUINO .................... 21
II.1 Introduction ................................................................................................................... 21
II.2 Notion d’Automate Programmable Industriel (API) ..................................................... 21
II.3 Rôle d’un API dans les systèmes automatisés ............................................................... 22
II.4 Structure générale d’un API .......................................................................................... 22
a. Module d’alimentation ............................................................................................. 23
b. Unité centrale (CPU) ................................................................................................ 23
c. Modules d’entrées .................................................................................................... 23
d. Modules de sorties .................................................................................................... 23
e. Interfaces de communication ................................................................................... 23
II.5 Différence API industriel / Arduino pédagogique ......................................................... 24
API industriel : ................................................................................................................. 24
Arduino : .......................................................................................................................... 24
II.6 Présentation de la carte Arduino ........................................................................................ 24
II.6.1 Définition .................................................................................................................... 24
II.6.2 Architecture matérielle ............................................................................................... 25
II.6.3 Microcontrôleur .......................................................................................................... 26
II.6.4 Caractéristiques techniques ........................................................................................ 27
II.6.5 Entrées / Sorties numériques et analogiques .............................................................. 27
a. Entrées numériques .................................................................................................. 27
b. Sorties numériques ................................................................................................... 27
c. Entrées analogiques .................................................................................................. 27
II.7 Environnement de programmation Arduino ...................................................................... 28
II.7.1 Arduino IDE ............................................................................................................... 28
II.7.2 Structure d’un programme .......................................................................................... 29
II.7.4 Moniteur série ............................................................................................................. 29
II.9 Composants utilisés dans le projet..................................................................................... 30
II.10 Schéma de câblage....................................................................................................... 30
II.11 Explication du Fonctionnement Simulation ........................................................... 31
7
II.12 Schéma de câblage conception .................................................................................... 36
II.12 Explication du Fonctionnement conception ........................................................... 36
II.13 Implémentation Logicielle (Code Arduino) ............................................................ 36
CONCLUSION GÉNÉRALE .................................................................................................. 39
8
INTRODUCTION GÉNÉRALE
Contexte
Les systèmes automatisés occupent une place stratégique dans les installations techniques
modernes, notamment dans les secteurs du bâtiment, de l’industrie et des infrastructures de
service. Parmi ces systèmes, l’ascenseur constitue un dispositif emblématique combinant
mécanique, électrotechnique et logique de commande. Son fonctionnement repose sur une
coordination précise entre capteurs, organes de puissance et unité de contrôle.
Dans les installations réelles, la gestion de la logique de déplacement, des appels d’étage et
des sécurités est assurée par des Automates Programmables Industriels. Ces équipements sont
conçus pour fonctionner de manière fiable dans des environnements exigeants et pour
exécuter des séquences logiques déterministes.
Dans un cadre pédagogique, il est possible de reproduire cette logique de commande en
utilisant une carte microcontrôleur telle qu’Arduino, qui permet de simuler le comportement
d’un API à petite échelle.
Problématique
La compréhension des systèmes séquentiels automatisés nécessite une approche pratique
permettant de visualiser les états, les transitions et les conditions logiques. Cependant, l’accès
direct aux API industriels peut être limité dans un contexte de travaux pratiques. Il devient
donc nécessaire de mettre en place une solution de substitution permettant de reproduire les
mécanismes de commande de manière didactique.
La question centrale est donc :
comment simuler de façon fiable la commande d’un ascenseur multi-étages en utilisant
une plateforme Arduino jouant le rôle d’un automate programmable ?
Objectifs du projet
Les objectifs de ce mini-projet sont multiples :
• Étudier le principe de fonctionnement d’un ascenseur
• Identifier les éléments de commande et de signalisation
• Définir les entrées et sorties du système
• Construire une logique séquentielle de commande
• Modéliser le cycle de fonctionnement (type GRAFCET)
• Implémenter la commande sur Arduino
• Réaliser une maquette de simulation avec LED et boutons
• Tester et valider le comportement du système
• Mettre en place une interface homme-machine (IHM) via un écran LCD pour le suivi
en temps réel de la position de la cabine et la simulation visuelle des cycles
d'ouverture et de fermeture des portes.
9
Méthodologie
La démarche adoptée repose sur plusieurs étapes structurées :
1. Étude documentaire du système ascenseur
2. Analyse fonctionnelle
3. Définition du cahier des charges
4. Modélisation séquentielle
5. Conception du schéma de commande
6. Câblage de la maquette
7. Programmation Arduino
8. Tests et validation expérimentale
Organisation du rapport
Le document est structuré en plusieurs chapitres progressifs :
présentation du système, description de la plateforme de commande, analyse fonctionnelle,
conception de la logique, réalisation pratique, puis évaluation des résultats.
10
CHAPITRE I — GÉNÉRALITÉS SUR
LES ASCENSEURS
I.1 Introduction
Le transport vertical des personnes et des charges constitue un besoin fondamental dans les
bâtiments à plusieurs niveaux. L’ascenseur est le système technique le plus utilisé pour
répondre à cette exigence. Il permet d’assurer un déplacement rapide, sécurisé et contrôlé
entre différents étages, tout en respectant des contraintes strictes de sécurité et de fiabilité.
Un ascenseur moderne n’est pas seulement un dispositif mécanique ; il s’agit d’un système
automatisé complet intégrant des capteurs, des actionneurs, des dispositifs de sécurité et une
unité de commande programmable. Cette unité de commande exécute une logique
séquentielle qui gère les appels, les déplacements, les arrêts, l’ouverture des portes et les
priorités de service.
Dans le cadre de ce mini-projet, l’ascenseur n’est pas réalisé physiquement à l’échelle réelle.
Son fonctionnement est reproduit par simulation à l’aide d’une commande logique
implémentée sur une carte Arduino, jouant le rôle d’un automate programmable. Avant
d’aborder cette simulation, il est indispensable de comprendre les principes réels de
fonctionnement des ascenseurs.
I.2 Définition d’un ascenseur
Un ascenseur est un système de levage vertical guidé, destiné au transport de personnes ou de
marchandises entre différents niveaux d’une construction. Il fonctionne grâce à une cabine se
déplaçant le long de rails de guidage, actionnée par un système de traction ou de poussée, et
pilotée par une commande automatique.
Un ascenseur comprend généralement :
• une cabine
• un système de guidage
• un mécanisme d’entraînement
• une structure de support
• des capteurs de position
• un système de commande
• des dispositifs de sécurité
• un système de signalisation
Le déplacement est contrôlé de manière automatisée selon des demandes d’appel provenant
des étages ou de l’intérieur de la cabine.
Figure I.1 — Vue générale d’un système d’ascenseur et de ses principaux sous-ensembles
(diagramme cabine + rails + moteur + contrepoids + armoire de commande)
11
I.3 Historique et évolution
Les premiers systèmes de levage remontent à l’Antiquité, où des mécanismes rudimentaires à
cordes et poulies étaient utilisés pour hisser des charges. Ces dispositifs reposaient sur la force
humaine ou animale.
L’évolution majeure intervient au XIXᵉ siècle avec l’introduction :
• des systèmes à vapeur
• des mécanismes de sécurité anti-chute
• des structures guidées
L’invention du frein de sécurité a permis le transport de personnes en réduisant le risque de
chute libre. Plus tard, l’arrivée des moteurs électriques a transformé les ascenseurs en
systèmes plus rapides, plus fiables et plus contrôlables.
12
Aujourd’hui, les ascenseurs modernes intègrent :
• commande électronique
• variateurs de vitesse
• capteurs numériques
• automates programmables
• supervision intelligente
• optimisation énergétique
I.4 Catégories d’ascenseurs
Les ascenseurs peuvent être classés selon plusieurs critères techniques :
a. Selon le mécanisme d’entraînement
• Ascenseurs hydrauliques
• Ascenseurs électriques à traction
b. Selon l’usage
• Ascenseurs pour passagers
• Ascenseurs de charge
• Monte-charges industriels
• Ascenseurs hospitaliers
• Ascenseurs panoramiques
c. Selon la vitesse
• Basse vitesse
• Moyenne vitesse
• Haute vitesse
Figure I.2 — Classification des ascenseurs selon le principe d’entraînement
13
I.5 Ascenseurs hydrauliques
Les ascenseurs hydrauliques utilisent la pression d’un fluide (huile) pour déplacer la cabine.
Un groupe hydraulique injecte le fluide dans un vérin, ce qui provoque la montée de la cabine.
La descente s’effectue par relâchement contrôlé de la pression.
Caractéristiques :
• fonctionnement basé sur un vérin
• adapté aux bâtiments de faible hauteur
• vitesse modérée
• forte capacité de charge
• installation simplifiée
• consommation énergétique plus élevée en montée
Avantages :
• grande force disponible
• mécanique simple
• bonne stabilité
Inconvénients :
• hauteur limitée
• besoin d’un local technique
• rendement énergétique inférieur
Figure I.3 — Principe de fonctionnement d’un ascenseur hydraulique (vérin + centrale
hydraulique)
14
Figure I.3 : Les différents modèles des ascenseurs hydrauliques
I.6 Ascenseurs à traction à câble
Les ascenseurs à traction sont les plus répandus. Ils fonctionnent à l’aide :
• d’un moteur électrique
• d’une poulie motrice
• de câbles
• d’un contrepoids
Le moteur entraîne la poulie, ce qui provoque le déplacement opposé de la cabine et du
contrepoids.
Caractéristiques :
15
• adapté aux bâtiments élevés
• vitesse élevée possible
• bon rendement énergétique
• précision d’arrêt
• commande électronique avancée
Variantes :
• avec réducteur
• sans réducteur (gearless)
• avec variateur de fréquence
Figure I.4 — Ascenseur à traction : cabine, câbles, poulie et contrepoids
I.7 Structure mécanique d’un ascenseur
Un ascenseur comprend plusieurs éléments mécaniques essentiels :
a. Cabine
Espace de transport des passagers ou charges.
b. Rails de guidage
16
Assurent un déplacement vertical stable.
c. Contrepoids
Compense une partie de la masse de la cabine pour réduire l’effort moteur.
d. Système d’entraînement
Moteur + poulie ou vérin hydraulique.
e. Portes
Portes cabine et palières avec verrouillage de sécurité.
f. Dispositifs de sécurité
• parachute mécanique
• limiteur de vitesse
• capteurs de fin de course
Figure I.5 — Composition mécanique détaillée d’un ascenseur
17
I.8 Principe général de fonctionnement
Le fonctionnement global repose sur une logique séquentielle :
1. Réception d’un appel d’étage
2. Analyse de la position actuelle
3. Détermination du sens de déplacement
4. Mise en marche du moteur
5. Déplacement contrôlé
6. Détection d’arrivée
7. Arrêt précis
8. Ouverture des portes
9. Temporisation
10. Fermeture des portes
C’est exactement cette logique séquentielle que ton mini-projet Arduino va simuler.
18
Figure I.6 — Cycle fonctionnel simplifié d’un ascenseur
I.9 Critères de choix d’un type d’ascenseur
Le choix dépend de :
• hauteur du bâtiment
• nombre d’étages
• charge utile
• fréquence d’utilisation
• vitesse requise
• consommation énergétique
• espace disponible
• coût d’installation
• exigences de sécurité
I.10 Domaines d’application
Les ascenseurs sont utilisés dans :
• immeubles résidentiels
• bâtiments administratifs
• hôpitaux
• industries
• centres commerciaux
• hôtels
• parkings automatisés
19
I.11 Conclusion
Ce chapitre a présenté les bases techniques nécessaires à la compréhension des systèmes
d’ascenseurs : définition, types, architecture mécanique et principe de fonctionnement. Ces
éléments constituent le socle théorique indispensable pour aborder la phase suivante du projet,
consacrée aux systèmes de commande et à leur simulation à l’aide d’une plateforme Arduino
assimilée à un automate programmable.
20
CHAPITRE II — AUTOMATE
PROGRAMMABLE ET CARTE
ARDUINO
II.1 Introduction
La commande des systèmes automatisés modernes repose sur des unités de contrôle capables
de traiter des informations d’entrée, d’exécuter une logique de décision et de piloter des
actionneurs de sortie. Dans l’industrie, cette fonction est assurée par des Automates
Programmables Industriels (API). Ces équipements sont conçus pour fonctionner de manière
robuste, continue et déterministe.
Dans un cadre pédagogique ou de prototypage, il est possible de reproduire les principes de la
commande automatisée à l’aide de plateformes microcontrôlées telles que les cartes Arduino.
Bien que destinées initialement à l’apprentissage et au prototypage rapide, ces cartes
permettent de mettre en œuvre des logiques séquentielles comparables à celles d’un API.
Dans ce projet, la carte Arduino est utilisée comme automate programmable didactique
pour simuler la commande d’un ascenseur multi-étages.
II.2 Notion d’Automate Programmable Industriel (API)
Un Automate Programmable Industriel est un dispositif électronique de commande conçu
pour piloter des processus automatisés en environnement industriel. Il remplace les anciens
systèmes à relais câblés en offrant une solution programmable, flexible et évolutive.
Un API assure principalement trois fonctions :
• acquisition des signaux d’entrée (capteurs, boutons, détecteurs)
• traitement logique selon un programme
• commande des sorties (moteurs, voyants, électrovannes)
Les API sont conçus pour :
• résister aux perturbations électriques
• fonctionner en continu
• garantir un temps de réponse déterministe
• assurer une grande fiabilité opérationnelle
Figure II.1 — Architecture générale d’un automate programmable industriel (modules
d’entrées, unité centrale, modules de sorties)
21
7v a 12v DC) Broches Entrésanalogiques
d’alimentation
Sorties PWM Communication
ConnecteurUSB
E/S
Digital
Connecteur jack
(entrée
d’alimentationde
II.3 Rôle d’un API dans les systèmes automatisés
Dans un système automatisé, l’API constitue le centre décisionnel. Il coordonne le
fonctionnement global en fonction de l’état des capteurs et des consignes reçues.
Ses rôles incluent :
• surveillance des entrées logiques
• exécution d’algorithmes de commande
• gestion des séquences
• temporisation des actions
• gestion des priorités
• pilotage des actionneurs
Dans le cas d’un ascenseur réel, l’API :
• lit les boutons d’appel
• détecte la position cabine
• décide du sens de déplacement
• commande le moteur
• gère l’ouverture des portes
• applique les règles de sécurité
II.4 Structure générale d’un API
Un API est généralement structuré autour des blocs suivants :
22
a. Module d’alimentation
Fournit l’énergie électrique régulée au système.
b. Unité centrale (CPU)
Exécute le programme utilisateur et gère le cycle de scrutation.
c. Modules d’entrées
Reçoivent les signaux provenant du terrain.
d. Modules de sorties
Commandent les dispositifs de puissance.
e. Interfaces de communication
Permettent la programmation et la supervision.
Figure II.2 — Schéma bloc de la structure interne d’un API
23
II.5 Différence API industriel / Arduino pédagogique
Bien que la carte Arduino puisse simuler certaines fonctions d’un API, des différences
importantes existent.
API industriel :
• certifié pour usage industriel
• robuste électriquement
• modules E/S isolés
• langages normalisés (Ladder, Grafcet, ST)
• sécurité intégrée
Arduino :
• plateforme pédagogique
• microcontrôleur généraliste
• E/S directes non isolées
• programmation en C/C++
• prototypage rapide
Dans ce mini-projet, Arduino est utilisé comme équivalent fonctionnel simplifié d’un API,
uniquement pour la simulation logique
Tableau II.1 — Comparaison API industriel vs Arduino
Critère API industriel Arduino (usage
pédagogique)
Domaine Industrie réelle Formation, prototypage
d’utilisation
Robustesse Très élevée Moyenne
Protection électriqueIntégrée À ajouter
Programmation Langages normalisés (Ladder, FBD, C/C++ simplifié
ST)
Tension E/S 24V standard 5V / 3.3V
Modules d’extension Industriels certifiés Shields
Coût Élevé Très faible
Maintenance Normée Libre
Certification Industrielle Éducative
Usage dans ce projet Référence théorique Plateforme de simulation
II.6 Présentation de la carte Arduino
II.6.1 Définition
24
Arduino est une plateforme électronique ouverte basée sur un microcontrôleur programmable.
Elle permet de développer rapidement des systèmes interactifs en combinant matériel et
logiciel.
Elle est largement utilisée pour :
• l’apprentissage
• le prototypage
• les projets embarqués
• la simulation de systèmes automatisés
II.6.2 Architecture matérielle
Une carte Arduino typique comprend :
• microcontrôleur
• régulateur de tension
• oscillateur
• ports E/S numériques
• entrées analogiques
• interface USB
• mémoire programme
Figure à insérer ici :
Figure II.3 — Carte Arduino annotée avec ses principaux composants
25
II.6.3 Microcontrôleur
Le microcontrôleur est le cœur de la carte.
Il intègre :
• processeur
• mémoire flash
• mémoire RAM
• registres E/S
• timers
• interfaces série
Il exécute le programme chargé par l’utilisateur.
Figure II.4 — Schéma interne simplifié d’un microcontrôleur
26
II.6.4 Caractéristiques techniques
Exemples typiques (Arduino Uno) :
• tension logique : 5 V
• E/S numériques : 14
• entrées analogiques : 6
• fréquence : 16 MHz
• mémoire flash : 32 KB
Tableau II.2 — Caractéristiques techniques de la carte utilisée
Paramètre Valeur
Microcontrôleur ATmega328P
Tension de fonctionnement 5V
Tension alimentation 7–12 V
Entrées numériques 14
Sorties PWM 6
Entrées analogiques 6
Fréquence horloge 16 MHz
Mémoire Flash 32 KB
SRAM 2 KB
EEPROM 1 KB
Courant par broche 20 mA
II.6.5 Entrées / Sorties numériques et analogiques
a. Entrées numériques
Lecture binaire (0/1) — boutons, capteurs TOR.
b. Sorties numériques
Commande binaire — LED, relais.
c. Entrées analogiques
Mesure de tension variable.
27
Dans ce projet ascenseur :
• boutons = entrées numériques
• LED = sorties numériques
II.7 Environnement de programmation
Arduino
II.7.1 Arduino IDE
L’IDE Arduino est le logiciel de développement permettant :
• écriture du code
• compilation
• téléversement
• débogage
Figure II.5 — Interface de l’Arduino IDE
Barredemenu
Barre debouton
Fenêtre
d’éditiondes
programmes
Messagesde
compilation
Information
surlacarteet
leportutilisé
28
II.7.2 Structure d’un programme
Tout programme comprend :
• fonction setup()
• fonction loop()
II.7.4 Moniteur série
Outil d’affichage temps réel des données.
Figure II.7 — Fenêtre du moniteur série
29
II.9 Composants utilisés dans le projet
- Arduino Uno
- Moteur pas à pas 28BYJ-48 avec son driver ULN2003
- 3 boutons poussoirs
- Fils Dupont
- Carte d’expérimentation (breadboard)
- Alimentation 5V
II.10 Schéma de câblage
Interface d'affichage et signalisation : Pour la simulation interactive sur Proteus, le schéma
intègre également un écran LCD (Liquid Crystal Display) connecté aux broches de la carte
Arduino. Cet écran permet d'afficher les messages d'état de l'ascenseur. Le circuit de
commande inclut également la logique de temporisation pour simuler virtuellement l'état des
portes de la cabine.
30
II.11 Explication du Fonctionnement
Simulation
1. Gestion de l'affichage et simulation des portes : Afin de rendre la simulation logicielle
plus réaliste et interactive, le système intègre une gestion avancée de l'affichage via
l'écran LCD et une temporisation pour les portes :
2. Initialisation et Positionnement : Au repos, l'écran affiche la position actuelle de
l'ascenseur (par exemple G pour le rez-de-chaussée, 1, ou 2).
3. Indication de Mouvement : Lorsqu'une commande est validée, l'écran indique la
direction et la progression de la cabine (ex: UP [1] ou DOWN [0]). Un délai de 2 à 3
secondes est appliqué entre chaque palier franchi pour simuler de manière réaliste le
temps de trajet de la cabine d'un étage à l'autre.
4. Séquence des Portes : À l'arrivée à l'étage ciblé, l'écran LCD affiche le message Door
Opened (Porte ouverte). Cet état est maintenu pendant 3 à 5 secondes pour simuler
l'entrée et la sortie des passagers. Ensuite, l'écran affiche Door Closed (Porte fermée)
et le système observe une pause de 1 à 2 secondes avant de pouvoir accepter une
nouvelle requête.
Diagramme montage du LCD
31
Code de simulation arduino pour Proteus
#include <LiquidCrystal.h>
LiquidCrystal lcd(7,6,5,4,3,2);
/* ===== BROCHES ===== */
const int boutonEtage[5] = {0,8,9,10,11};
const int ledEtage[5] = {0,8,9,10,11};
int etageActuel = 1;
int etageCible = 0;
/* ===== ETATS ===== */
enum Etat {
ATTENTE,
PORTE_OUVERTE_DEPART,
FERMETURE_DEPART,
DEPLACEMENT,
PORTE_OUVERTE_ARRIVEE,
RETOUR_MAISON
};
Etat etatSysteme = ATTENTE;
unsigned long chrono = 0;
const unsigned long tempoPorte = 2000;
const unsigned long tempoMouvement = 1500;
32
void setup(){
[Link](16,2);
for(int i=1;i<=4;i++){
pinMode(boutonEtage[i], INPUT_PULLUP);
pinMode(ledEtage[i], OUTPUT);
}
afficherEtage();
activerLED(etageActuel);
}
void loop(){
switch(etatSysteme){
case ATTENTE:
lireBouton();
break;
case PORTE_OUVERTE_DEPART:
gererPorte("Ouverture...");
etatSysteme = FERMETURE_DEPART;
break;
case FERMETURE_DEPART:
gererPorte("Fermeture...");
etatSysteme = DEPLACEMENT;
break;
case DEPLACEMENT:
gererDeplacement();
break;
case PORTE_OUVERTE_ARRIVEE:
gererPorte("Arrivee - Ouvert");
etatSysteme = RETOUR_MAISON;
break;
case RETOUR_MAISON:
if(etageActuel != 1){
etageCible = 1;
etatSysteme = DEPLACEMENT;
} else {
etatSysteme = ATTENTE;
}
break;
33
}
}
/* ===== LECTURE ===== */
void lireBouton(){
for(int i=1;i<=4;i++){
if(digitalRead(boutonEtage[i]) == LOW && i != etageActuel){
etageCible = i;
etatSysteme = PORTE_OUVERTE_DEPART;
}
}
}
/* ===== DEPLACEMENT PRECIS ===== */
void gererDeplacement(){
static unsigned long tempsPrecedent = 0;
if(millis() - tempsPrecedent >= tempoMouvement){
tempsPrecedent = millis();
if(etageActuel < etageCible){
etageActuel++;
[Link]();
[Link]("Montee...");
}
else if(etageActuel > etageCible){
etageActuel--;
[Link]();
[Link]("Descente...");
}
afficherEtage();
activerLED(etageActuel);
if(etageActuel == etageCible){
etatSysteme = PORTE_OUVERTE_ARRIVEE;
}
}
}
/* ===== GESTION PORTE ===== */
void gererPorte(String message){
34
[Link]();
[Link](message);
delay(tempoPorte);
[Link]();
[Link]("Porte Fermee");
delay(tempoPorte);
afficherEtage();
}
/* ===== AFFICHAGE ===== */
void afficherEtage(){
[Link](0,1);
[Link]("Etage : ");
[Link](etageActuel);
}
/* ===== LED ===== */
void activerLED(int etage){
for(int i=1;i<=4;i++){
digitalWrite(ledEtage[i], LOW);
}
digitalWrite(ledEtage[etage], HIGH);
}
35
II.12 Schéma de câblage conception
II.12 Explication du Fonctionnement
conception
Le système surveille en permanence l'état des trois boutons-poussoirs. Lorsqu'une pression est
détectée sur l'un d'eux :
1. Le programme identifie l'étage cible demandé.
2. Il calcule la distance relative (en nombre de pas) entre l'étage actuel et l'étage cible.
3. Le moteur effectue la rotation nécessaire (sens horaire ou anti-horaire) pour déplacer
la cabine.
4. Une fois l'étage atteint, la variable de position (etageActuel) est mise à jour pour la
prochaine commande.
II.13 Implémentation Logicielle (Code
Arduino)
Le code suivant utilise la bibliothèque Stepper.h pour piloter le moteur.
#include <Stepper.h> // Bibliothèque nécessaire pour la commande du moteur
36
// Définition du nombre de pas pour un tour complet du rotor (exemple pour
un 28BYJ-48)
const int pas_par_tour = 2048;
// Initialisation des ports de commande du moteur (8, 10, 9, 11)
Stepper moteur(pas_par_tour, 8, 10, 9, 11);
// Déclaration des broches pour les boutons
const int boutonRDC = 2;
const int bouton1 = 4;
const int bouton2 = 5;
// Variables de gestion d'état
int etageActuel = 0; // Position initiale au RDC
const int pasEntreEtage = 4500; // Nombre de pas requis pour passer d'un
étage à l'autre
void setup() {
pinMode(boutonRDC, INPUT);
pinMode(bouton1, INPUT);
pinMode(bouton2, INPUT);
[Link](10); // Établissement de la vitesse de rotation (RPM)
[Link](9600); // Initialisation du port série
[Link]("********************* BIENVENUE : MINI-PROJET ASCENSEUR
*********************");
[Link]("**** Quel étage ? ****");
}
void loop() {
// Enregistrement des états des boutons
int RDC = digitalRead(boutonRDC);
int etage1 = digitalRead(bouton1);
int etage2 = digitalRead(bouton2);
if (RDC == HIGH) {
allerAEtage(0);
etageActuel = 0;
}
else if (etage1 == HIGH) {
allerAEtage(1);
etageActuel = 1;
}
else if (etage2 == HIGH) {
allerAEtage(2);
etageActuel = 2;
}
}
// Fonction assurant l'atteinte de l'étage ciblé
void allerAEtage(int cible) {
if (cible == etageActuel) {
[Link]("Déjà à cet étage.");
return;
}
// Calcul de la différence de position
int difference = cible - etageActuel;
int pasNecessaire = difference * pasEntreEtage;
[Link]("Aller à l'étage : ");
[Link](cible);
37
[Link](pasNecessaire); // Commande du moteur
[Link]("Arrivée à l'étage : ");
[Link](cible);
[Link]("**** Quel étage ? ****");
delay(500); // Pause de sécurité
}
38
CONCLUSION GÉNÉRALE
La réalisation de ce mini-projet, portant sur la modélisation et la simulation du
fonctionnement d’un ascenseur à l’aide d’une carte Arduino, nous a permis de mettre en
pratique les concepts théoriques abordés dans le cadre du module Automate Programmable
Industriel (API).
Tout au long de ce travail, nous avons pu concevoir un système automatisé capable de gérer
les appels à différents étages (RDC, 1er et 2ème étage) en coordonnant les entrées (boutons-
poussoirs) et les sorties (moteur pas à pas). L'implémentation du code a nécessité une gestion
rigoureuse des états et des déplacements pour garantir la précision de l'arrêt aux niveaux
souhaités.
Sur le plan technique, ce projet nous a permis de :
• Maîtriser l'environnement de développement Arduino et le langage C++.
• Comprendre l'interaction entre les composants matériels et la logique de
programmation.
• Appréhender les problématiques de contrôle de mouvement et de gestion des priorités
dans un système embarqué.
Dans le contexte de notre Master en Énergie Renouvelable et Environnement, cette
expérience est d'autant plus pertinente qu'elle souligne l'importance de l'optimisation des
systèmes motorisés. En perspective, ce prototype pourrait être amélioré par l'ajout de capteurs
de fin de course pour une sécurité accrue, d'un afficheur LCD pour l'interface utilisateur, ou
encore par une réflexion sur l'efficacité énergétique des cycles de montée et descente.
En somme, ce projet a constitué une étape enrichissante dans notre formation, renforçant notre
capacité à concevoir des solutions technologiques concrètes et automatisées répondant à des
besoins de mobilité verticale.
39