Mémoire de projet de fin d’étude

Présenté par
OUSOUHA MUSTAPHA
MARDOULI MERYEM
MBAIRA OLAYA
En vue de l’obtention du diplôme
Licence Universitaire en Sciences et Techniques
Ingénierie et Management des Systèmes Industrielle

Thème

« Automate programmable
industrielle À base d’Arduino »
Encadré par:
Mr. Houssine LIMOUNY

Année Universitaire:
2021/2022
 Remerciements

Avant tout développement, il apparait opportun de commencer ce

rapport de fin d’études par nous remerciements, à DIEU le tout puissant, à
ceux qui nous a beaucoup appris au cours de ce projet de fin d’etude.

Nous présentons nos vifs remerciements à Mr.Houssine LIMOUNY,

notre encadrant pédagogique à la Faculté des Sciences et Technique
d’Errachidia, pour sa grande disponibilité, sa rigueur, son enthousiasme et
son soutien moral qui nous a permis de mener à bien ce travail.

Aussi nos vifs remerciements s’adressent aux membres du jury et ainsi

aux professeurs qui nous est énormément aidé avec leurs cours, ainsi que
tout le corps administratif et professoral de la FSTE pour la qualité de la
formation et services rendus aux étudiants.
 DEDICACES
Nous dédions ce modeste travail à :

 NOUS parents, sœurs et toute famille pour leurs sacrifices

 A nous parents …Que nulle dédicace ne puisse exprimer ce que nous vous devons,
pour votre bienveillance, votre affection, votre soutien et vos sacrifices…Que dieu
vous garde et vous accorde santé et longue vie.

 A nous frères et soeurs et Grande Famille……

 A nous ami(e)s à la FSTE et tous ceux, qui nous a aimés et soutenus

inconditionnellement
 A tous ceux qui nous aiment et nous encouragent …

 A tous celles et ceux qui, de près ou de loin, ont collaboré à la réalisation de ce

travail.

 Nous vifs remerciements.

 MR. PROF Houssine LIMOUNY

 NOUS professeurs

 Tous nos amis(es) avec lesquels nous partageons les moments

 Tous ceux qui nous ont aidés de près ou de loin pour la réalisation de ce travail

 Tous ceux et celles que nous aimons et qui nous aiment

 Liste des figures
Chapitre01: LES AUTOMATES PROGRAMMABLES INDUSTRIELS
Figure1.1: Technologies possibles pour la réalisation de la PC
Figure1.2: API
Figure1.3: API Compact S7-1200
Figure1.4: API Modulaire S7-300
Figure1.5: Architecture matérielle d’un API
Figure1.6: Fonctionnement cyclique d’un API

Chapitre02: DESCRIPTION DE L’ARDUINO

Figure2.1: Arduino IDE
Figure2.2: Arduino barre de menu
Figure2.3: Arduino barre de programmation
Figure2.4: Arduino uno
Figure2.5: Les entrées/sorties numériques
Figure2.6: Les entrées analogiques

Chapitre03: CONTROLE ET SURBEILLANCE DE LA VITESSE D’UN MOTEUR

EN FONCTION DE LA TEMPERATURE AVEC ARDUINO
Figure3.1: Brochage du capteur LM35DZ
Figure3.2: Arduino UNO
Figure3.3: LM35DZ
Figure3.4: Transistor 2N222
Fidure3.7: Led
Figure3.6: Condensateur
Fifure3.5: Resistance 1KOhm
Figure3.10: Moteur
Figure3.9: Cable de connexion
Fifure3.8: Fils de connexion

Figure3.12: Diode 1N4007

Figure3.11: Plaque d’essai
Figure3.13: Schéma du circuit
Figure3.12: Montage réel
Figure3.15: Programme
Figure3.16: Résultats de mesure

Liste des tableaux

Tableau1.1: Prix d’un API

Tableau2.1: Les types des cartes Arduino
Tableau2.2: Prix des cartes Arduino
Tableau3.2: Matériels
Tableau3.1: Fonction des broches
 Sommaire
INTRODUCTION GENERALE.....................................................................1
CHAPITRE 01: LES AUTOMATES PROGRAMMABLES INDUSTRIELS

INTRODUCTION..................................................................................................................................................2

I. Historique.........................................................................................................................................................3

II. API – Definition..............................................................................................................................................4

III. API – Domaines d’utilisation.........................................................................................................................5

IV. API – Avantages et inconvenients.................................................................................................................5

V. API – Différents catégories et Prix.................................................................................................................5

VI. Les types des automates..................................................................................................................................7

i. Aspect extérieur..........................................................................................................................................7
ii. Aspect interne …........................................................................................................................................8

VII. Fonctionnement cyclique d’un API.............................................................................................................9

VIII. Caractéristiques d'automate programmable industriel...............................................................................9

IX. Le choix d'automate programmable industriel...........................................................................................10

X. Les langages de programmation..................................................................................................................10

CHAPITRE 02 : DESCRITION DE L’ARDUINO

INTRODUCTION...............................................................................................................................................11
I. Arduino-Historique.................................................................................................................................12
II. Arduino logiciel.......................................................................................................................................12
i. Arduino IDE- Définition........................................................................................................12
ii. Comment obtenir l’IDE Arduino........................................................................................13
 III. Arduino matériel.........................................................................................................................................15

i. Arduino-Prix: ........................................................................................................................16
ii. Matèriels et Logiciels derives................................................................................................17
iii. Matèriels et Logiciels libres...................................................................................................17
iv. Arduino et IoT.......................................................................................................................17

IV. Arduino uno..............................................................................................................18

i. Micro-contrôleur...................................................................................18
ii. Interface USB/Série..............................................................................18
iii. Alimentation.........................................................................................19
iv. Entrées/sorties.......................................................................................20
v. Topologie de la carte Arduino UNO R3……………………………...21
vi. Alimentation de la carte Arduino UNO R3…………………………..21

V. Protection de la carte Arduino....................................................................................22

i. Protection des entrées numériques........................................................22

ii. Protection du port USB.........................................................................22

iii. Protection des composants....................................................................22

iv. Circuit de puissance..............................................................................22

VI. Circuit de commande................................................................................................23

CHAPITRE03 : CONTROLE ET SURBEILLANCE DE LA VITESSE D’UN MOTEUR

EN FONCTION DE LA TEMPERATURE AVEC ARDUINO

INTRODUCTION……………………………………………………………………….24
I. Matériels……………………………………………………………………………..25
i. Capteur de température LM35DZ……………………………………25
i.1. A propos du capteur………………………………25
i.2. Informations techniques sur LM35DZ……………25
i.3. Le brochage du capteur LM35DZ………………...26
ii. Les autres matériels…………………………………………………..26
II. Circuit…………………………………………………………………………………27
III. Fonctionnement du Circuit……………………………………………………………28
IV. Programme……………………………………………………………………………28
V. Explication du programme……………………………………………………………32
VI. Résultats de mesure…………………………………………………………………...33
VII. Conclusion…………………………………………………………………………….33
 INTRODUCTION GENERALE

Dans un monde industriel en pleine évolution ou la compétitivité est l'objectif essentiel, l'automatisation
est une nécessite.

C’est pourquoi l’homme s’est opté vers l’automatisation en fondant des usines intelligentes afin de
réussir une communication continue et instantanée entre les différents outils et postes de travail intégrés dans les
chaînes de production et d’approvisionnement, qui est le concept de l’industrie 3.0

Autrefois réserves aux applications spécialisées exigeant des volumes de traitement importants, les
automates programmables industriels sont maintenant opérationnels dans de nombreux domaines, de
l'aéronautiques jusqu'a l'électroménager. De par la simplicité de leur mise en œuvre et de leur implantation, ils
occupent une place importante dans les technologies utilisées en automatisation.

Cependant, le prix de ces derniers est remarquablement très élevé. D'où le besoin d'un substituant qui
cout pas très cher et réalisé les mêmes fonctions des automates programmables industriels.

L'un des substituant des automates programmables industriels les plus connus est l'Arduino. Ce sont des cartes a
base des microcontrôleurs qui réalisent les mêmes tâches d'automatisation que les automates programmables
industriels et qui sont affordables pour tout le monde.

On vise à travers cette étude la présentation des automates programmables industriels et de l'Arduino
afin de traiter une application d'une fonction ou les APIs est utilisé et la réaliser avec l'Arduino.

En étant des personnes passionnées par la programmation et l’innovation technologique, on a décidé

donc d’approfondir nos recherches sur ce sujet, en fixant un plan qui sont réparties en plusieurs chapitres

1
 Résume

L’objet de notre étude d’une application de l’automate programmable industriels qui nous peuvent remplacer

par l’Arduino, avant de tout ça ont faire une étude détailler sur des outils Software et Hardwarede l’automates

programmable industriels et ça remplacent Arduino et particulièrement Arduino de type UNO

Notre projet sera composé de trois chapitres :

Chapitre01: on a donné un aperçu détaille sur les automates programmables industriels

Chapitre02: Dans ce chapitre on a étudié l'Arduino, les types des cartes, les microcontrôleurs utilises

dans chaque model, les prix et beaucoup d'autres choses.

Chapitre03: Ce chapitre est consacré à l'étude et la réalisation d'une application par l’Arduino qui est

généralement faite par les automates programmables industriels dans le train.

2
 CHAPITRE 01: LES AUTOMATES PROGRAMMABLES INDUSTRIELS

INTRODUCTION :

Les progrès technologiques de ces dernières années ont abouti au développement des automates programmables
industriels (En anglais : Programmable Logic Controller (PLC)) et à une révolution conséquente de l’ingénierie
de contrôle/commande. Actuellement, l’industrie des automates programmables connait un développement
technologique remarquable, et suivant la bôme technologique des systèmes à microprocesseur. Ces avancées
affectent non seulement la conception des automates programmables, mais aussi l’approche philosophique de
l’architecture du système de contrôle. Alors, c’est quoi un automate programmable industriel ? Qui sont ses
caractéristiques, ses domaines d’utilisation, sa structure, … ? Comment programmer un-API? ……..

3
 I. Historique
Les automatismes séquentiels ont été réalisés, depuis longtemps, à base de relais électromagnétiques.
L’inconvénient c’est qu’il s’agit d’un système câblé ce qui impose la refonte complète du câblage et ceci pour la
moindre modification dans l’ordonnancement des séquences. En 1966, l’apparition des relais statiques a permis
de réaliser des divers modules supplémentaires tel que le comptage, la temporisation, le pas à pas ... Cependant
cette technologie avait le même problème : technologie câblée. En 1968 et à la demande de l’industrie
automobile nord-américaine, sont apparus les premiers dispositifs de commande logique aisément modifiable :
Les PLC (Programmable Logic Controller) par Allen Bradley, Modicom et Digital Equipement. Le premier
dispositif français était le PB6 de Merlin Gerin en 1973.

Figure1.1: Thechnologies possibles pour la realisation de la PC

Avant: utilisation de relais électromagnétiques et de systèmes pneumatiques pour la réalisation des parties
commandes.
⇒ logique câblée
Inconvénients: cher, pas de flexibilité, pas de communication possible.

Solution: utilisation de systèmes à base de microprocesseurs permettant une modification aisée des systèmes
automatisés .
⇒ logique programmée
Les ordinateurs de l'époque étant chers et non adaptés aux contraintes du monde industriel, les automates
devaient permettre de répondre aux attentes de l'industrie. Contraintes du monde industriel :
 influences externes: - poussières
4
 - température
- humidité
- vibrations
- parasites électromagnétiques
 Personnel : - mise en œuvre du matériel aisée (pas de langage de programmation complexe)
- dépannage possible par des techniciens de formation électromécanique
- possibilité de modifier le système en cours de fonctionnement
 Matériel : - évolutif
- modulaire
- implantation aisée

II. API – Définition

Norme NFC 63-850: « Appareil électronique qui comporte une mémoire programmable par un utilisateur
automaticien (et non informaticien) à l’aide d’un langage adapté, pour le stockage interne des instructions
composant les fonctions d’automatisme pour commander, mesurer et contrôler au moyen de modules d’entrées
et de sorties (logiques, numériques ou analogiques) différentes sortes de machines ou de processus, en
environnement industriel. » C’est donc une machine électronique qui se place entre deux grands courants : la
logique câblée et le calculateur universel

Figure 1.2: API

Ils peuvent être considérés en termes simples comme des ordinateurs industriels dotés des interfaces d’Entrées/Sorties
et des fonctions spécialement conçues. La figure 1.2 illustrée le diagramme conceptuel d’un système à base d’API

5
 III. API – Domaines d’utilisation
On utilise les API dans tous les secteurs industriels pour la commande des machines (convoyage, emballage ...)
ou des chaînes de production (automobile, agroalimentaire ... ) ou il peut également assurer des fonctions de
régulation de processus (métallurgie, chimie ...). Il est de plus en plus utilisé dans le domaine du bâtiment
(tertiaire et industriel) pour le contrôle du chauffage, de l'éclairage, de la sécurité ou des alarmes.

IV. API – Avantages et inconvénients

Par rapport à un ordinateur industriel, un automate programmable industriel présente un certain
nombre d’atouts indéniables:

 Praticité : Le dispositif réagit immédiatement aux indications données par les capteurs. Pour cause,
il dispose de circuits électroniques optimisés qui assurent un temps d’exécution minimal.
 Facilité de  maintenance  : Les modules obsolètes peuvent très facilement être remplacés. De plus,
l’automate redémarre sans problème après des travaux d’entretien ou de maintenance.
 Robustesse  : Les composants de l’appareil sont suffisamment solides pour pouvoir fonctionner
dans des environnements particulièrement hostiles (variations de température, vibrations des
supports, perturbations électromagnétiques, etc.)
 Fonctionnement sécurisé : Le dispositif est conçu pour se protéger contre tout éventuel dommage
occasionné par les coupures d’alimentation intempestives. Lors de la réalimentation, l’appareil assure un
démarrage correct, avec une reprise à chaud ou à froid.

En contrepartie, ils sont plus chers que des solutions informatiques classiques à base de microcontrôleurs par
exemple mais restent à l'heure actuelle les seules plateformes d'exécution considérées comme fiables en milieu
industriel (avec les ordinateurs industriels).

V. API – Différents catégories et Prix

Les automates programmables industriels sont répartis sous 3 grandes catégories, à savoir :

 Les automates programmables standard : Les versions les plus basiques fonctionnent de
manière séquentielle et suivent un mode de programmation pas à pas. Ils n’exécutent l’instruction
suivante qu’une fois la commande précédente entièrement effectuée. Les automates plus
sophistiqués, quant à eux, sont paramétrés à l’aide d’un programmeur spécifique ou d’un
ordinateur. Ces modèles garantissent un dépannage, une modification et une lecture faciles.

6
  Les nano automates embarqués : prend la forme d’un mini boitier étanche. En général, ce
modèle se présente comme une version miniature d’un automate programmable standard. Il est
surtout utilisé par les constructeurs de machines de petits et moyens volumes.
 Les automates programmables de sécurité : En plus des applications habituelles, un
automate de sécurité dispose d’une fonction de diagnostic. C’est pourquoi ce modèle coûte plus
cher que les autres automates. Le prix peut monter jusqu’à 5 000 €, selon les options
de diagnostic proposées. La fonction de diagnostic permet de repérer à temps toute
éventuelle défaillance interne du micrologiciel ou de l’appareil. Des micro-impulsions servent à
enclencher la routine de diagnostic et à lire l’état de la sortie. En cas de dysfonctionnement ou de
détérioration d’un élément, le dispositif avertit l’utilisateur pour que celui-ci puisse prendre les
mesures adaptées. L’alerte se fait soit au moyen d’une alarme, soit à travers un affichage
 La marque : automate programmable industriel Sterkelec, automate industriel programmable
Schneider, automate programmable Technideal, automate programmable industriel Atmel  ..

Figure1.3:Prix d’un API

7
 VI. Les types des automates
i. Aspect extérieur

Les automates peuvent être de type compact ou modulaire.

 Automate de type compact

Il intègre le processeur, l'alimentation, les entrées et les sorties.

Selon les modèles et les fabricants, il pourra réaliser certaines
fonctions supplémentaires (comptage rapide, E/S analogiques ...) et
recevoir des extensions en nombre limité.
Ces automates, de fonctionnement simple, sont généralement
destinés à la commande de petits automatismes (micro automate).

Figure1.4 API Compact S7-1200

 Automate de type modulaire

le processeur, l'alimentation et les interfaces d'entrées / sorties résident

dans des unités séparées (modules) et sont fixées sur un ou plusieurs
racks contenant le "fond de panier" (bus plus connecteurs).

Ces automates sont intégrés dans les automatismes complexes où de

puissance, capacité de traitement et flexibilité sont nécessaires

Figure1.5 API Modulaire S7-300

8
ii. Aspect interne

9
 Figure1.4: Architecture materielle d’un API

 Module d’alimentation : il assure la distribution d’Energie aux diffèrent modules.

 Unité centrale : à base de microprocesseur, elle réalisé toutes les fonctions logiques,
arithmétiques et de traitement numérique (transfert, comptage, temporisation…).
 Le bus interne : Il permet la communication de l’ensemble des blocs de l’automate et des
éventuelles extensions.
 Mémoires : Elles permettent de stocker le système d’exploitation (ROM ou PROM). Le
programme (EEPROM) et les données système lors du fonctionnement (RAM). Cette dernière
est généralement secourue par pile ou batterie. On peut, en règle générale, augmenter la capacite
mémoire par adjonction de barrettes mémoires type PCMCIA.
 Console de programmation : Le dispositif de programmation est utilisé pour introduire le
programme souhaité dans la mémoire programmable. Généralement le programme est développé
dans un PC ou une console spéciale donnée par le constructeur, puis transféré dans la mémoire
du CPU par l’intermédiaire d’un câble de communication adéquat (MPI-bus, TCP/IP...Etc.).
 Module de communication : L’interface de communication est utilisée pour recevoir et
transmettre des données sur des réseaux de communication depuis ou vers d’autres systèmes
distants tells que API, SCADA F&G, HMI, serveur OPC ...etc. Il concerne des actions telles que
la vérification du périphérique, l’acquisition de données, la synchronisation entre les systèmes et
la gestion de la connexion.

 Interfaces d’entrées/ sorites :

 Interface d’entrée : elle permet de recevoir les informations du S.A.P. ou du pupitre et
de mettre en forme (filtrage,..) ce signal tout en l’isolant électriquement(optocoupleur).
 Interface de sortie : elle permet de commander les divers PR actionneurs et éléments de
signalisation su S.A.P. tout en assurant l’isolement électrique.

10
 VII. Fonctionnement cyclique d’un API

Figure 1.5: Fonctionnement cyclique d’un API

Un API travail d’une façon cyclique, dont la fonction de base est de lire toutes les entrées depuis les modules d’entrées
puis, il exécute le programme de contrôle selon la logique programmée stockée dans la mémoire, puis il fait la mise à
jours de toutes les sorties. Ce dernier processus de mise à jour des modules d’interface de sortie, activant ou désactivant
les appareils de terrain connectés à chaque terminal d’interface. Ce processus de lecture des entrées, d’exécution du
programme et de mise à jour des sorties est appelé un cycle de balayage (Scanning cycle). La figure (1.2) représente le
fonctionnement cyclique d’un API.

VIII. Caractéristiques d'automate programmable industriel

 Les types d'automate (compact et modulaire)
 Tension d'alimentation (220VCA,24VCA,24VCC)
 Taille mémoire (8Ko,24Ko)
 Nombres d'Entrée/Sorties (12E/8S,24E/12S ...)
 Temps de scrutation (20ms,10ms ...)
 Types de sorties (Relais, Transistor)
 Encombrement et protection (Dépend de l'implantation)
 Sauvegarde (Mémoire EPROM, EEPROM, pile…)
 Langages de programmation (Langage propriétaire constructeur)
 Langages de programmation (Langage propriétaire constructeur)
 Logique des Entrées TOR (Logique positive ou négative)
 Modules complémentaires (Communications, Entrées/Sorties Analogiques, Dialogue...)

IX. LE CHOIX D'AUTOMATE PROGRAMMABLE INDUSTRIEL :

Le choix d'un automate programmable est généralement basé sur :

11
Nombre d'entrées / sorties : le nombre de cartes peut avoir un effet sur le nombre de racks dès que le nombre
d'entrées / sorties nécessaires devient élevé.

Type de processeur : la taille mémoire, la vitesse de traitement et les fonctions spéciales offertes par le
processeur permettront le choix dans la gamme souvent très étendue.

Le temps de cycle : certains automates ont des temps de cycle plus rapides face à d'autres ce qui peut être
important pour des systèmes nécessitant une certaine réactivité.

La communication : l'automate doit pouvoir communiquer avec les autres systèmes de commande et fournir
des possibilités de communication avec des standards normalisés.

La programmation : Si des programmes spécifiques ont été appliqués à un API bien particulier, il convient de
se tourner vers ce type d’automate à l’avenir. Les futures programmations d’automates n’en seront que
facilitées.

Le prix : on va choisir un prix juste et raisonnable pour le type d'API nécessaire. S'il s'agit d'un automate pour
un petit projet, il est préférable de choisir des mini automates.

Fonctions ou modules spéciaux : certaines cartes (commande d'axe, pesage ...) permettront de soulager le
processeur et devront offrir les caractéristiques souhaitées (résolution, ...).

X. Les langages de programmation

L’écriture d’un programme consiste à créer une liste d’instructions permettant l’exécution des opérations
nécessaires au fonctionnement du système L’API traduit le langage de programmation en langage
compréhensible directement par le microprocesseur. Ce langage est propre à chaque constructeur, il est lié au
matériel mis en œuvre.

12
Il existe différents types de Langage de programmation:

 Le langage GRAFCET (SFC (Sequential Fonction Chart)

Le langage GRAFCET permet de représenter graphiquement, et de façon structurée, le fonctionnement
d’un automatisme séquentiel. Il met en œuvre :
 Des blocs fonctions prédéfinis (compteurs, temporisations, etc.).
 Des fonctions métiers (analogique, communication, contage, etc.).
 Des fonctions spécifiques (gestion du temps, chaîne de caractères, etc.).
 Le langage à contact (Ladder LD, Ladder Diagram)
Langage graphique développé pour les électriciens .il utilise les symboles graphiques standardises
(contacts, bobines …).
Les symboles sont organisés en réseaux de la même manière que les branches d’un schéma logique a
contact.il est essentiellement dédie a la programmation d’équations booléennes (true /false).
C’est le plus utilise. C’est une simple traduction des circuits de commande électriques.
 Le langage LIST (Liste d’instructions)
Le langage liste d’instructions est un langage « machine » booléen. Il permet l’écriture de traitements
logiques et numériques.
 Le langage booléen (Logigramme)
Ce langage est basé sur l’écriture d’équation logique qui utilise quatre opérateurs de base.

13
 CHAPITRE 2 : DESCRITION DE L’ARDUINO

INTRODUCTION :

Les cartes Arduino conçues pour réaliser prototypes et des maquettes de cartes électroniques pour
l'informatique embarquée. Ces cartes permettent un accès simple et peu couteux a l'informatique embarquée. De
plus, elles sont entièrement libres de droit, autant sur l'aspect du code source (Open Source) que sur l'aspect
matériel (Open Hardware). Ainsi, il est possible de refaire sa propre carte Arduino dans le but de l'améliorer ou
d'enlever des fonctionnalités inutiles au projet.

Le langage Arduino se distingue des langages utilisés dans l'industrie de l'informatique embarquée de par sa
simplicité. En effet, beaucoup de librairies et de fonctionnalités de base occulte certains aspects de la
programmation de logiciel embarquée afin de gagner simplicité. Cela en fait un langage parfait pour réaliser des
prototypes ou des petites applications dans le cadre de passe-temps.

Le système Arduino permet de :

 Contrôler les appareils domestiques

 Faire un jeu de lumières
 Communiquer avec l'ordinateur
 Télécommander un appareil mobile
 Etc...

I. Arduino-Historique

Le projet Arduino est issu d’une équipe d’enseignants et d’étudiants de l’école de Design d’Interaction
d’Ivrea (Italie). Ils rencontraient un problème majeur à cette période (2003-2004) ; les outils nécessaires à la
création de projet d’interactivité étaient complexes et onéreux (entre 80 et 100 euros).

14
 Les outils de prototypage étaient principalement dédiés à l’ingénierie, la robotique et aux domaines
techniques. Leur préoccupation se concentre alors sur la réalisation d’un matériel moins cher et plus facile à
utiliser.

En 2003, Heranado Barragan, pour sa thèse de fin d’études, avait entrepris le développement d’une carte
électronique dénommée « Wiring », accompagnée d’un environnement de programmation libre et ouvert. Cette
carte a donc inspiré le projet Arduino (2005) et conçu par une équipe de professeurs et d’étudiants (David
Mellis, Tom Igoe, Gianluca Martino, David Caurtielles, Massimo Banzi et Nicholas Zambetti).

II. Arduino logiciel

i. Arduino IDE- Définition

 Arduino IDE est un logiciel open source qui est principalement utilisé pour écrire et compiler le
code dans le module Arduino.
 Il s'agit d'un logiciel officiel introduit par Arduino.cc, rendant la compilation de code trop facile
pour que même une personne ordinaire sans connaissances techniques préalables puisse se
familiariser avec le processus d'apprentissage.
 Il est facilement disponible pour les systèmes d'exploitation tels que MAC, Windows, Linux et
s'exécute sur la plate-forme Java qui est livrée avec des fonctions et des commandes intégrées
qui jouent un rôle essentiel pour le débogage, l'édition et la compilation du code dans
l'environnement.
 Presque tous les modules Arduino sont compatibles avec ce logiciel tel que : Arduino UNO,
Arduino Mega, Arduino Leonardo, Arduino Micro et beaucoup plus.
 Le code principal, également connu sous le nom de croquis, créé sur la plate-forme IDE générera
finalement un fichier hexadécimal qui sera ensuite transféré et téléchargé dans le microcontrôleur
de la carte.
 L'environnement IDE contient principalement deux parties de base : l'éditeur et le compilateur,
où le premier est utilisé pour écrire le code requis et le plus tard est utilisé pour compiler et
télécharger le code dans le module Arduino donné.
 Cet environnement prend en charge les langages C et C++.

ii. Comment obtenir l’IDE Arduino

15
Nous pouvons télécharger le logiciel à partir du site Web ofeciel d'Arduino
https://www.arduino.cc/en/software ., Nous choisissons de télécharger la version correcte du logiciel qui est
facilement compatible avec notre système d'exploitation.

 Détails sur IDE

L'environnement IDE est principalement réparti en trois sections :

1. Menu bar (barre de menu).

2. Text Editor (éditeur de texte).
3. Output Pane (volet de sortie).
Lorsque nous téléchargeons et ouvrons le logiciel IDE, il apparaîtra comme la figure 2.1.

Figure 2.1: Arduino IDE

 La barre apparaissant en haut s'appelle la barre de menus qui comprend cinq options
différentes comme suit :

Figure2.2: Arduino barre de menu

16
  File : en français fichier, Nous pouvons ouvrir une nouvelle fenêtre pour écrire le code ou on ouvre
une existante.
 Edit : en français éditer. Utilisé pour copier et coller le code avec une modification supplémentaire
de la police.
 Sketch : en français esquisser. Utiliser pour compiler et programmer
 Tools : en français outils. Principalement utilisé pour tester des projets. La section Programmeur de
ce panneau est utilisée pour graver un chargeur de démarrage sur le nouveau microcontrôleur. Le
tableau suivant indique les subdivisions et leurs fonctions.
 Help : en français aide. Nous trouverons ici un accès facile à un certain nombre de documents
fournis avec le logiciel Arduino (IDE). Nous avons accès à la mise en route, à la référence, à ce
guide de l'IDE et à d'autres documents localement, sans connexion Internet. Les documents sont une
copie locale des documents en ligne et peuvent renvoyer au site Web en ligne.
 Les six boutons apparaissant sous l'onglet Menu sont connectés au programme en cours d'exécution
comme suit :

Figure 2.3: Arduino barre de programmation

 La coche apparaissant dans le bouton circulaire sert à vérifier le code. Cliquez dessus une
fois que vous avez écrit votre code.
 La touche fléchée téléchargera et transférera le code requis sur la carte Arduino.
 Le papier pointillé est utilisé pour créer un nouveau fichier.
 La flèche vers le haut est réservée à l'ouverture d'un projet Arduino existant.
 La flèche vers le bas est utilisée pour enregistrer le code en cours d'exécution.
 Le bouton apparaissant dans le coin supérieur droit est un moniteur série - une fenêtre
contextuelle distincte qui agit comme un terminal indépendant et joue un rôle vital pour
l'envoi et la réception des données série. Nous pouvons également accéder au panneau Outils
et sélectionner Serial Monitor en appuyant simultanément sur Ctrl + Maj + M pour ouvrir
Serial Monitor. Le moniteur série aidera en fait à déboguer les croquis écrits où vous pourrez
comprendre comment votre programme fonctionne. Votre module Arduino doit être connecté
à votre ordinateur par câble USB afin d'activer le moniteur série.

17
  Le bas de l'écran principal est décrit comme un volet de sortie qui met principalement en évidence l'état
de compilation du code en cours d'exécution : la mémoire utilisée par le code et les erreurs survenues
dans le programme. Vous devez corriger ces erreurs avant d'avoir l'intention de télécharger le fichier
hexadécimal dans votre module Arduino.

III. Arduino matériel

Les modules d'origine des différentes versions de l'Arduino sont fabriqués par la société italienne Smart
Projects. Quelques-unes des cartes de marque Arduino ont été conçues par la société américaine SparkFun
Electronics. Ci-dessous un tableau montre les différentes cartes Arduino en indiquant leurs dates de lancement,
microcontrôleur, et le nombres de pins d’entrées analogiques et numériques.

Lancée Numérique Analogique

Carte en microcontroleur Input Input
Diecimila 2007 ATmega 168 14 6
Uno 2010 ATmega328P 14 6
Leonardo 2012 ATmega32U4 20 7
Mega 2009 ATmega1280 54 15
Mega2560 2010 ATmega2560 54 15
Due 2012 Atmel SAM3XBE 54 12
Fio 2010 ATmega328P 14 6
Nano 2008 ATmega168 ou ATmega328 14 6
ATmega168V ou
LilyPad 2007 ATmega328V 14 6
Yun 2013 ATmega32U4 20 7
Esplora 2012 ATmega32U4 N/A N/A
101 2015 Intel Curie 14 4
Micro 2012 ATmega32U4 20 7
Zero 2015 ATSAMD21G18 20 18
MKR 2018 SAMD21 Cortex 22 12
Duemilanove 2008 ATmega168/328P 14 6
Ethernet 2011 ATmega328P 14 6
Edge Control 2020 nRF52840 6 28
Protenta Machine
Control 2020 STM32H747XI dual Cortex 20 8

Figure 2.4: Les types du cartes Arduino

18
i. Arduino-Prix:

Carte Prix(euro)
Arduino UNO Mini Limited Edition 40,00
Arduino UNORev3 20,00
Arduino UNO WiFi REV2 38,90
Arduino UNO REV3 SMD 19,00
Arduino Leonardo with Headers 18,00
Arduino Leonardo without Headers 16,00
Arduino Due 35,00
Arduino Due without Headers 34,00
Arduino Mega 2560 Rev3 35,00
Arduino Nano 18,00
Arduino Micro 18,00
Arduino Micro without Headers 16,00
Arduino Zero 32,38
Portenta H7 Lite Connected 82,00
Nicla Sense ME 59,00
Protenta H7 Lite 60,00
Arduino Nano RP2040 Connect with Hearders 22,00
Arduino Nano RP2040 Connect 21,00
Arduino MKR IoT Carrier 48,00
Arduino MLR nb 1500 66,90
Arduino MKR Vidor 4000 62,90
Arduino MKR WiFi 1010 27,90
Arduino MKR ZERO (I2S bus &SD for sound, music& digital audio data) 21,90
Arduino Nano 33 BLE 17,50
Arduino Edge Control 169,00
Nicla Vision 95,00
Arduino MLKR GSM 1400 59,90
Arduino Protenta Machine Control 279,92
Figure 2.5: Prix des cartes Arduino

19
 ii. Materiels et logiciels derives

Plusieurs cartes compatibles Arduino ont été produites par d'autres fabricants.
Plusieurs logiciels ont été développés pour faciliter la programmation des cartes Arduino. On retrouve entre
autres les solutions graphiques Ardublock, BitBloq et MiniBloq, ainsi que le pseudo-langage EDU qui permet
d'utiliser des mots-clés simplifiés.
Il existe aussi des cartes Arduino ou compatible modifiées pour un usage spécifique : par exemple, des cartes de
contrôle pour imprimantes 3D RepRap, des systèmes de pilote automatique pour drones comme les systèmes
ArduPilot, APM:Plane et APM:Copter, ou les cartes FlyDuino, enfin des puces Wi-Fi tierces comme
l'ESP8266 compatibles avec l'environnement Arduino.
Certains logiciels musicaux, comme le logiciel Usine Hollyhock, proposent grâce à leur module série une
intégration de l'Arduino dans le processus de création musicale.

iii. Matériels et logiciels libres

Le design matériel de l'Arduino est distribué sous licence Creative Commons Attribution Share-Alike 2.5 et est
disponible sur le site d'Arduino. Les schémas ainsi que les typons de circuits sont également disponibles. Le
code source de l'environnement de programmation et les bibliothèques embarquées sont disponibles sous
licence LGPL.
De nombreuses informations sont disponibles au sujet des circuits intégrés présents sur les cartes Arduino
(microcontrôleurs Atmega par exemple) même s'ils restent très fermés du fait des fabricants. Seul le nom
« Arduino » est protégé et ne doit pas être utilisé pour le matériel non officiel, ce qui a permis l’apparition de
marques telles que funduino, arduiboy, etc.
iv. Arduino et IoT

Arduino a lancé le 28 septembre 2016 une campagne Kickstarter pour financer le développement et la
commercialisation de la collection de modules IoT (Internet of Things - Internet des Objets) ESOLV. Le
financement a été annulé le 26 octobre 2016 par l'entreprise car l'objectif n'a pas été atteint selon les
prévisions avec la promesse que la solution continuera.
En avril 2017, Arduino lance ainsi une nouvelle gamme de cartes de développement, Arduino MKR [archive],
au format réduit, destiné à l'IoT. Ces cartes, fabriquées sous de multiples déclinaisons, disposent chacune de
fonctionnalités de connectivité spécifiques telles que Sigfox, Lora, Wi-Fi, etc.

20
IV. Arduino uno
i. Micro-contrôleur
C’est le cerveau de notre carte. Il va recevoir le programme que nous allons
créer et va le stocker dans sa mémoire avant de l’exécuter. Grâce à ce
programme, il va savoir faire des choses, qui peuvent être : faire clignoter une
LED, afficher des caractères sur un écran, envoyer des données à un
ordinateur, mettre en route ou arrêter un moteur…
La puce la plus courante qui équipe la carte Arduino est la ATMEGA328.
Certains anciens modèles ont une puce ATMEGA168 qui est dotée d'un peu
moins de mémoire. Les cartes Arduino Mega sont dotées d'une puce
ATMEGA644 qui a plus de mémoire et plus d'entrées/sorties. Tous les
processeurs de la famille ATMEGA se programment sensiblement de la même
manière mais des différences peuvent apparaître pour des fonctions plus
complexes
ii. Interface USB/Série

 Lorsque la carte Arduino communiquera avec l'ordinateur, il faudra

que ces deux dispositifs puissent se comprendre, donc "parler le même
langage".
Le premier type est la liaison simplex. Il n'y a qu'un émetteur et un
seul récepteur. Par exemple, seul l'ordinateur peut envoyer des
données à la carte Arduino. Ça nous n'est pas très utile si on veut faire
le contraire. On n'utilisera donc pas ce type de liaison.
 Le deuxième est la liaison half-duplex. En fait, c'est un peu lorsque Figure 2.6: Arduino Uno

l'on communique à quelqu'un avec un talkie-walkie. L'un parle

pendant que l'autre écoute. Nous n'utiliserons pas ce type de communication.

 Le dernier est la liaison full-duplex. Là, c'est un peu comme le téléphone, chacun peut parler et écouter
en même temps ce que l'autre dit. Avec Arduino, c'est de ce type de communication que nous disposons.
Ce qui est bien pratique afin d'éviter d'attendre que l'on ait réceptionné ce que l'ordinateur envoie pour
ensuite lui émettre des données.

21
 iii. Alimentation
Pour fonctionner, une carte Arduino a besoin d'une alimentation. Le microcontrôleur fonctionnant sous 5V, la
carte peut être alimentée directement en 5V par le port USB ou bien
par une alimentation externe qui est comprise entre 7V et 12V. Un régulateur se charge ensuite de réduire la
tension à 5V pour le bon fonctionnement de la carte.
Attention : les cartes Arduino Due ainsi que d'autres cartes récentes fonctionnent avec un voltage de 3.3V
au niveau des sorties ! Le voltage de l’alimentation est similaire à l’Arduino Uno.

iv. Entrées/sorties

 Les entrées/sorties numériques : de D0 à D13

o 14 entrées ou sorties numériques : de D0 à D13 Les signaux véhiculés par ces
connecteurs ne peuvent prendre que deux états HAUT (5 Volts) ou BAS (0 Volt).
Courant de 40 mA maximum par sortie.
o Les connecteurs D0 et D1 : sont réservés pour la liaison USB et ne sont donc pas
utilisés (RX et TX sont utilisés pour gérer les flux de données entrants et sortants).

Figure 2.7: les entrees/sorties

numeriques

 Les entrées analogiques : de A0 à A5

o Les entrées analogiques : La carte Arduino Uno possède six entrées analogiques notées
A0 à A5. Nous pouvons appliquer sur ces entrées des tensions comprises entre 0 et 5V
et le convertisseur analogique-numérique (à approximations successives des ATMega)
transforme ces tensions en mots binaires de 10 bits.
o 6 entrées analogiques : A0, A1, A2, A3, A4 et A5 Pour utiliser : photorésistance (LDR)
résistance ajustable potentiomètre, capteur de température… Les entrées analogiques
peuvent avoir 2 10, soit 1024 valeurs, allant de 0 à 1023.
Figure 2.8: Les entrees analogiques

22
  Entrées/sorties PWM : Les connecteurs D3, D5, D6, D9, D10 et D11, repérés par un ~, peuvent être
utilisés en sortie PWM (Pulse Width Modulation), pour faire varier la luminosité d’une DEL ou la
vitesse d’un moteur ou un servo moteur… Les sorties PWM peuvent avoir 28 , soit 256 valeurs, allant de
0 à 255.
v. Topologie de la carte Arduino UNO R3

Figure2.9: Arduino UNO composant Figure2.10: Arduino schema

Ref. Description Ref. Description

X1 prise d'alimentation 2.1*5.5mm U1 Régulateur SPX1117M3-L-5
X2 Connecteur USB U3 Module ATMEGA16U2
Condensateur CMS EEE-1EA470WP
PC1 25V U5 LM358BLIST-A.9IC
Condensateur CMS EEE-1EA470WP
PC2 25V F1 Condensateur à puce, haute densité
D1 Redresseur CGRA4007-G ICSP Connecteur d'en-tête de broche (à travers le trou 6)
j-ZU4 Module ATMEGA328P ICSP1 Connecteur d'en-tête de broche (à travers le trou 6)
Y1 Oscillateur ECS-160-20-4X-DU    

vi. Alimentation de la carte Arduino UNO R3

Description Min type Max Unit

tension d'entrée maximale du pad VIN 6 _ 20 V
23
tension d'entrée maximale du connecteur USB _ _ 5.5 V

Figure2.6: Topolgie de la carte Arduino UNO R3

 Tableau2.7: Alimentation de la carte Arduino UNO R3

V. Protection de la carte Arduino

i. Protection des entrées numériques
Comme leur configuration dépend du programme résident dans la carte Arduino, ce que l'on considère dans un
montage comme des entrées numériques peuvent accidentellement être configurées en sortie (avec la
commande pin Mode) et réglées à 0 V (LOW). Dans ce cas, si cette « entrée » reçoit du 5 V, il se produira un
court-circuit qui risque d'endommager partiellement ou intégralement la carte.
Pour éviter ce genre de mésaventure, lorsqu'on câble une entrée numérique, il est prudent d'y ajouter une
résistance de 100 Ω qui limite le courant en cas de fausse manœuvre.
ii. Protection du port USB
Tout d'abord, il faut savoir que le port USB de votre ordinateur délivre une quantité limitée de courant
électrique. En général un port USB peut fournir au maximum 500 mA en 5 V. Si vous souhaitez réaliser un
montage qui nécessite plus de courant, il s'agira de prévoir une alimentation externe suffisamment puissante
pour répondre à votre besoin.
iii. Protection des composants
Chaque composant possède ses propres conventions d'utilisation. Par exemple, il existe des composants qui
possèdent un sens de branchement à respecter. L'on dit que ces composants sont polarisés. C'est le cas des LED,
de certains condensateurs, des diodes, etc. La plupart des composants ne peuvent pas fonctionner seuls, par
exemple une LED a besoin d'une résistance appropriée pour ne pas s'user ou « brûler ».
Cette résistance permet de limiter le courant qui traverse la LED. Le courant supprimé est alors dissipé en
chaleur par la résistance.
iv. Circuit de puissance
Ce circuit alimente les composants nécessitant beaucoup d'énergie (habituellement les moteurs et autres
actionneurs). Sa tension d'alimentation dépend des composants en question. En fonction de cette tension et des
conditions d'utilisation, les précautions à prendre sont variables :
 Dans tous les cas, une protection contre les courts-circuits est conseillée : fusible ou disjoncteur
pour éviter de détruire les composants.

24
  Au-dessus de 50 V, la tension peut menacer directement les humains : protéger les pièces nues sous
tension.
 Le 230 V nécessite un interrupteur différentiel qui protège les humains des contacts accidentels (en
général tout local est doté de ce dispositif). Ne pas manipuler de 230V sans connaissances appropriées.
Il est important de noter que ces deux circuits sont montés distinctement et sont isolés l'un de l'autre.
Toutefois, il est primordial de lier leur masse -GND- afin qu'ils partagent le même potentiel de
référence.

VI. Circuit de commande

Comme son nom l'indique, c'est dans ce circuit que sont rassemblés tous les éléments de contrôle comme les
boutons, les interfaces et le microcontrôleur. Il est alimenté en basse tension : moins de 50 V, souvent 12 V, ou
avec la carte Arduino 5 V. L'on pourrait l'assimiler au système nerveux d'un organisme : c'est ici que se
prennent les décisions mais peu d'énergie y circule.
La manière la plus simple de relayer les commandes émergeant de ce circuit pour les transmettre au circuit de
puissance est d'utiliser des transistors ou encore des relais.
Lorsque les tensions d'alimentation des deux circuits sont plus importantes ou si l'on veut protéger la commande
de retours accidentels de courant provenant de la puissance, des optocoupleurs (plutôt que des transistors)
assurent une isolation galvanique : l'information est transmise sous forme de lumière. Ainsi, les deux circuits
sont complètement isolés électriquement.

25
CHAPITRE03: CONTROLE ET SURVEILLACE DE LA VITESSE D’UN MOTEUR EN
FONCTION DE LA TEMPERATURE AVEC ARDUINO

INTRODUCTION :

Dans ce chapitre, on va décrire comment concevoir le contrôle et la surveillance de la vitesse d’un ventilateur
en fonction de la température en utilisant l’Arduino et le capteur de température LM35DZ. La carte Arduino
UNO contrôle la vitesse du ventilateur électrique en fonction des besoins et permet un contrôle dynamique et
rapide. La température détectée en degrés Celsius et la vitesse du ventilateur en pourcentage sont affichées
simultanément.

Les domaines d'application de ce projet sont les climatiseurs, les chauffe-eaux, les déneigeuses, les fours, les
échangeurs de chaleur, les mélangeurs, les fours, les incubateurs, les bains thermaux et les tables d'opération
vétérinaires.

26
VIII. Matériels
i. Capteur de température LM35DZ
i.1. A propos du capteur

 Le LM35 est l'un des capteurs de température les plus populaires et utilisé, centigrade de précision, peu
coûteux fabriqué par Texas Instruments . Il est encapsulé dans un emballage similaire à celui des
transistors. Il fournit une tension de sortie linéairement proportionnelle à la température Centigrade et
est donc très facile à utiliser avec l’Arduino.
 Le capteur ne nécessite aucun étalonnage ou ajustement externe pour fournir des précisions de ± 0,5 ° C
à température ambiante et de ± 1 ° C sur la plage de température de −50 ° C à + 155 ° C.
 L’un des inconvénients du capteur est qu’il nécessite une tension de polarisation négative pour lire les
températures négatives.

i.2. Informations techniques sur LM35DZ

 Ce capteur de température permet d'acquérir une température ambiante.

 Une fois alimenté, il va délivrer une tension analogique proportionnelle à la température.
 Tension d'alimentation (Tension de fonctionnement) : entre 4V à 30V.
 Étendue de mesure :  0°C à 100°C.
 Précision :  ±0,75 °C (typique)/ 1.5°C aux extrêmes.
 Echelle: 10mV/°C.
 Calibre pour les degrés Celsius : 0mV a 0° C, 1000mV a 100 °C.
 Liaison de donnée: Analogique.
 Faible impedance de sortie.
 Faible courant d’alimentation(60uA).
 Faible cout.
i.3. Le brochage du capteur LM35DZ
Nom Epingler Description
Vcc 1 Broche d'alimentation positive(4-30V)
vout 2 sortie analogique du capteu de temperature
Broche de terre de l'appareil, connecte27a la borne
GND 3
negative de l'alimentation
Figure3.1: Brochage du capteur LM35DZ
Tableau3.1: Fonction des broches
ii. Les autres matériels

Quantit
Materiels Description
e
Carte Arduino Arduino UNO R3 1
Capteur de LM35DZ capteur de temperature
1
temperature analogique
Moteur 5V CC 1
Transistor 2N2222 NPN 1
Resistance 1K 2
Diode 1N4007 1
Condensateur 10uF 1
Fils de connection _ _
Led Rouge 5mm 1
Plaque d'essai _ _

Tableau3.2: Materiels

Figure3.2: Arduino UNO Figure3.3: LM35DZ Figure3.4: Transistor 2N222

Fifure3.5: Resistance 1KOhm Figure3.6: Condensateur Fidure3.7: Led

28
 Fifure3.8: Fils de connection Figure3.9: Cable de connection Figure3.10: Moteur

Figure3.11: Plaque d’essai Figure3.12: Diode 1N4007

IX. Circuit

29
 Figure3.13: Schema du circuit Figure3.12: Montage reel

X. Fonctionnement du Circuit
Le capteur de température LM35 détecte la température et la convertit en un signal électrique (analogique), qui
est appliqué au microcontrôleur ATmega328 de la carte Arduino UNO. La valeur analogique est convertie en
une valeur numérique. Ainsi, les valeurs détectées de la température et de la vitesse du moteur. Lorsque la
température dépasse 20°C, le ventilateur commence à tourner. Un signal de modulation de largeur d'impulsion
(PWM) basse fréquence, dont le rapport cyclique varie pour ajuster la vitesse du moteur utilise. Le transistor est
efficace car il est utilisé comme interrupteur.
XI. Programme

Figure3.15: Programme

30
int tempPin = A0; // sortie de LM35DZ
int mot = 11; // sortie moteur
int led = 8; // Sortie Led
int temp;
int tempMin = 10; // la temperature min pour demarrer le moteur 0%
int tempMax = 30; // la temperature max lorsque la vitesse egale 100%
int motSpeed;
int motLCD;

void setup() {
pinMode(mot, OUTPUT);
pinMode(led, OUTPUT);
pinMode(tempPin, INPUT);
Serial.begin(9600);
}

void loop()
{
temp = readTemp(); // prend la valeur de la temperture
Serial.println( temp );
if(temp < tempMin) // si temp est inferieur a la temperature min
{
motSpeed = 0; // aucune rotation de la part du moteur
analogWrite(mot, motSpeed);
motLCD=0;
digitalWrite(mot, LOW);
}
if((temp >= tempMin) && (temp <= tempMax)) // si temp est inclue dans l'intervalle
[tempMin.tempMax]
{

31
motSpeed = temp;//map(temp, tempMin, tempMax, 0, 100); // la vitesse actuelle du moteur//map(temp,
tempMin, tempMax, 32, 255);
motSpeed=1.5*motSpeed;
analogWrite(mot, motSpeed); // rotation du moteur a la valeur du motSpeed vitesse
}

if(temp > tempMax) // si temp est superieur a tempMax

{
digitalWrite(led, HIGH); // Led on
}
else // else Led off
{
digitalWrite(led, LOW);
}

Serial.println("TEMP: ");
Serial.print(temp); // afficher la temperature
Serial.print("C ");
Serial.println(" MOTSPEED: ");
Serial.print( motLCD); // afficher la vitesse
Serial.print("%");
delay(2000);

int readTemp() { // convertir la temperature en Celisius

temp = analogRead(tempPin);
return temp * 0.48828125;
}

32
XII. Explication du programme
 Dans la première partie du programme on initialise les variables et leurs pins analogiques et numériques
correspondants d'une façons permanente, c'est à dire qu'ils ne vont pas changer tout le long du
programme ce sont des variables globales.
 Concernant la deuxième partie du code on déclare la fonction setup() qui utilisée pour initialiser les
variables locales. C'est une fonction qui n'est exécutée qu'une seule fois et qui ne renvoie pas de valeur-
void-. Dans la fonction setup(), on a fait appel a la fonction pinMode() qui permet de configurer comme
entrée ou sortie les paramètre déclares-dans notre code on a déclaré les variables mot et led comme
sorties et temPin comme entrée. La fonction Serial.begin(9600) passe la valeur 9600 au paramètre
vitesse. Cela indique à l'Arduino de se préparer à échanger des messages avec le moniteur série à un
débit de données de 9600 bits par seconde.
 La troisième partie de ce programme commence par la fonction loop()-boucle en aglais- fait exactement
ce que son nom sugge et s'exécute en boucle sans fin, permettent au programme de s'exécuter et de
répondre, elle est utilisé pour contrôler activement la carte Arduino et ne renvoie pas elle aussi aucune
valeur . Au sein de cette dernière, on a déclaré la variable temp et utilise la fonction Serial.println()
pour afficher sa valeur dans une nouvelle ligne. On a fait appel a L'instruction if() pour étudier les cas.
Dans le premier cas -if(temp,tempMin)- si cette instruction est réalisé la valeur de la vitesse du moteur
va égale a 0.Apres on a déclaré l'instruction Apres on a déclaré l'instruction
analogWrite(mot,motSpeed), qui va générer une onde carrée stable avec un"duty cycle"-Fraction de la
période ou la broche est au niveau haut-de longueur spécifiée -en pourcentage-, jusqu'a l'appel suivant
de l'instruction analogWrite(ou bien encore l'appel a l'instruction digitalRead sur la même broche). la
fréquence de l'onde PWM est approximativement de 490Hz. Apre on affecte la valeur 0 a la variable
motLCD et ensuite en fait appel a la fonction digitalWrite(mot,LOW) qui envoie une valeur LOW au
pin digital (broche numérique) préconfigure comme sortie, puisque le pin a été configure comme
OUTPUT avec la fonction pinMode(), son voltage s'établit dans sa valeur respective 0V pour la valeur
LOW. Dans la ligne suivante, on a annonce le 2eme cas-if((temp>=tempMin)&&(temp<=tempMax))-,
dans ce cas la vitesse du moteur-motSpeed- sera égale a la valeur du variable temp ainsi que la valeur
novelle de la vitesse du moteur va égale a 5 fois la valeur ancienne qui est implicitement la valeur de du
variable temp. Apres on a déclaré l'instruction analogWrite(mot,motSpeed).Pour le troisième cas -
33
 if(temp>tempMax)-, on fait appel encore une fois à la fonction digitalWrite(led,HIGH) qui est aussi
configure comme un OUTPUT c'est a dire son voltage s'établit dans la valeur 5V. Pour le 4eme cas-
else-, la led sera éteinte.
 Pour les 5 lignes du code qui suit, le programme va écrire la valeur du variable temp et la vitesse du
moteur avec un décalage de 2000 ms.
 Dans les trois lignes dernières du code, on va convertir la température capter en dégrée Celsius, affecter
la valeur capter par analogRead(tempPin) aux variables temp, et enfin faire renvoyer la valeur
temp*0.48828125.
XIII. Résultats de mesure

34
Figure3.16: Resultats de mesure

35
XIV. Conclusion

Après avoir réalisé cette application, il nous apparait clair que l’automatisation à jouer un major rôle dans le
développement du secteur industriel. Comme il déjà cite précédemment les automates programmables
industriels couts une somme importante d’argent, d’où l’Arduino est venu comme un alternatif qui nous a aider
réalise cette application d’automatisation industrielle avec des outils qui ne coute pas cher et que tout le monde
peut trouver facilement afin d’arrive a réalisé un système d’automatisation industriel qui ressemble a celui
qu’on trouve dans le monde industriel. Il est certain que l’Arduino est un outil très important qui représente
l’automation d’un point de vue innovant.

36
 Conclusion générale

Après une période d’étude sur les Arduino et les APIs ainsi que la recherche sur le sujet qui nous
a été attribué comme projet de fin d’étude (Automate programmable industrielle À base d’Arduino) .

Nous avons acquis suffisamment de connaissance bien varies dans les différents domaines
technologiques en particulier en ce qui concerne l’électrique et l’électronique.

Au terme de cette période, dont nous pensons avoir pleinement profité, elle a permis d'une part
de mettre en pratique certaines connaissances et notions acquises lors de notre formation et d'autre part
elle nous a donné l'opportunité d'acquérir un esprit de collaboration et de travail en groupe. Malgré les
difficultés rencontrées lors de la réalisation de notre projet, notamment au niveau des équipements. Ce
dernier nous a permis d’acquérir un esprit de synthèse en matière de conception, et de trouver les bonnes
solutions aux problèmes rencontres.

Ce projet vient donc de compléter notre formation et nous apporter une flexibilité dans nos
compétences et notre savoir-faire

Enfin, nous espérons que ce travail sera mené jusqu’au bout par d’autres étudiants.

37
 BIBLIOGRAPHIE

: chap 2 arduino references

https://www.arduino.cc
www.Scribd.com
www.Tunisia_sat.com
https://arduino.education
wikipedia arduino
https://www.researchgate.net/publication/
328615543_Integrated_Development_Environment_IDE_For_Arduino
https://docs.arduino.cc/software/ide-v1/tutorials/arduino-ide-v1-basics#file
chap1 api references
wikipedia
https://www.uvt.rnu.tn/resources-uvt/cours/Automates/chap2/co/Module_chap2_6.html
https://www.institut-numerique.org/v-conclusion-4e1b375ea8549
https://conseils.hellopro.fr/guide-de-prix-des-automates-programmables-industriels-1560.html#:~:text=Les
%20automates%20programmables%20industriels%20sont,Les%20automates%20programmables%20de
%20sécurité.
https://www.eeinap.com/2019/12/automates-programmables-ep3.html
https://www.automation-sense.com/forum/forum-automatisme-industriel/quels-sont-les-automates-prog…
http://hu.jean-louis.pagesperso-orange.fr/systeme/automate/caracapi.html
: https://www.usinenouvelle.com/article/choisir-un-automate-programmable-industriel.N1888737
https://www.futura-sciences.com
www.abcdelectronique.com

38
 Liste des abréviations
API : Automate Programmable Industriel

PLC : Programmable Logic Controller

PB6 : Puteaux Bureaux numéro 6

E/S : Entrée /Sortie

RAM : Read Access Memory

ROM : Read Only Memory

PROM : Programmable Read-Only Memory

EEPROM : Electrically-Erasable Programmable Read-Only Memory

PCMCIA : Personal Computer Memory Card International Association

MPI : Multi Point Interface

TCP /IP : Transmission Control Protocol/Internet Protocol

SCADA F & G : Supervisory Control And Data Acquisition Fire & Gas

HMI : Interface Homme Machine

OPC : Ordonnancement Pilotage et Coordination

CPU : Central Processing Unit

VCA : Voltage Current alternative

VCC : Voltage Current Continue

TOR : The Onion Router

SFC : Syndrome de Fatigue Chronique

LD : Laser Disc

USB : Universal Serial Bus

LED : Lighting Electricaly Diode

39
MAC : Media Access Control

IDE : Integrad Develepement Environment

PWM : Pulse Width Modulation

GND : Ground (mass)

APM : Application Performance Monitoring

IOT : Internet of Things

LDR : Light Dependent Resistor

DEL : Diode ElectroLuminescente

N /A : Numérique /Analogique

LGPL : Lesser General Public License

V : Volt

Ko : kilo ohm

°C : Celsius

μA: Micro ampere

μF : Micro farad

mm: millimetre

CC : Courant Continue

40