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

Theme

« 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
Liste des figures
Chapitre01: Les Automates Programmales Industriels
Figure1.1: Thechnologies possibles pour la realisation de la PC
Figure1.2: API
Figure1.3: API Compact S7-1200
Figure1.4: API Modulaire S7-300
Figure1.5: Architecture materielle 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 entrees/sorties numeriques
Figure2.6: Les entrees analogiques

Chapitre03: Application
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: Risistance 1KOhm
Figure3.10: Moteur
Figure3.9: Cable de connection
Fifure3.8: Fils de connection
Figure3.12: Diode 1N4007
Figure3.11: Plaque d’essai
Figure3.13: Schema du circuit
Figure3.12: Montage reel
Figure3.15: Programme
Figure3.16: Resultats de mesure

Liste des tableaux

Tableau1.1: Prix d’un API

Tableau2.1: Les types des carts Arduino
Tableau2.2: Prix des cartes Arduino
Tableau3.2: Materiels
Tableau3.1: Fonction des broches
 Sommaire
INTRODUCTION GENERALE.....................................................................1
CHAPITRE 1: 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 – Differents categories et Prix................................................................................5

VI. Les types des automate.................................................................................................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 2 : DESCRITION DE L’ARDUINO

INTRODUCTION..............................................................................................................11
I. Arduino-Historique.................................................................................................12
II. Arduino logiciel......................................................................................................12
i. Arduino IDE- Definition.......................................................................12
ii. Comment obtenir l’IDE Arduino.......................................................13

III. Arduino matériel........................................................................................................15

i. Arduino-Prix: .......................................................................................16
 ii. Materiels et Logiciels derives...............................................................17
iii. Materiels 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

CHAPITRE 3 : CONTROLE ET SURBEILLANCE DE LA VITESSE D’UN MOTEUR

EN FONCTION DE LA TEMPERATURE AVEC ARDUINO

INTRODUCTION……………………………………………………………………….24
I. Mareriels……………………………………………………………………………..25
i. Capteur de temperature 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 materiels…………………………………………………..26
II. Circuit…………………………………………………………………………………27
III. Fonctionnement du Circuit……………………………………………………………28
IV. Programme……………………………………………………………………………28
V. Explication du programme……………………………………………………………32
VI. Resutlats de mesure…………………………………………………………………...33
VII. Conclusion…………………………………………………………………………….33
 INTRODUCTION GENERALE

Dans un monde industriel en pleine evolution ou la competitivite est l'objectif essentiel, l'automatisation
est une necessite.

Autrefois reserves aux applications spacialisees exigeant des volumes de traitement importants, les
automates programmables industriels sont maintenant operationnels dans de nombreux domaines, de
l'aeronitiques jusqu'a l'electromenager. De par la simplicite de leur mise en ouvre et de leur implantation, ils
occupent une place importante dans les technologies utililsees en automatisation.

Cependant, le prix de ces derniers est remarquablement tres eleve. D'ou le besoins d'un substituant qui
cout pas tres cher et realise les memes fonctions des automates programmables industriels.

L'un des substituant des autommates programmables industriels les plus connus est l'Arduino. Ce sont des cartes
a base des microcontroleurs qui realisent les memes taches 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 utilise et la realiser avec l'Arduino. Notre projet
sera composé de trois chapitres :

Chapitre1: on a donné un aperçu detaile sur les automates programmables industriels

Chapitre2: Dans ce chapitre on a etudie l'Arduino, les types des cartes, les microcontroleurs utilises dans chaque
models, les prix et beaucoup d'autres choses.

Chapitre3: Ce chapitre est consacre a l'etude et la realisation d'une application par l'arduino qui est generalement
faite par les automates programmables industriles dans le terain.
 CHAPITRE 1: 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 le 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 atomate programmable industriel? Qui sont ses
caracteristiqes, ses domaines d’utilisation, sa strecture, …? Comment programmer un API? ……..
 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’une système câblée 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
- 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 – Definition

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
 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 inconvenients

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 – Differents categories 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.
 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

 VI. Les types des automate
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

ii. Aspect interne :

 Figure1.4: Architecture materielle d’un API

 Module d’alimentation: il assure la distribution d’energie aux different modules.

 Unite centrale: a base de microprocesseur, elle realise toutes les fonctions logiques,
arithmetiques et de traitement numerique(transfert, comptage, temporization…).
 Le bus interne: Il permet la communication de l’ensemble des blocs de l’automate et des
eventuelles extensions.
 Memoires: Elles permetent de stocker le systeme d’exploitation(ROM ou PROM). Le
programme(EEPROM) et les donnees systeme lors du fonctionnement(RAM). Ctte derniere est
generalement secourue par pile ou batterie. On peut, en regle generale, augmenter la capacite
memoire par adjunction de barrettes memoires 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é 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’entrees/ 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 electriquement(optocouplage).
 Interface de sortie: elle permet de commander les divers preactionneurs et elements de
siganlisation su S.A.P. tout en assuarant l’isolement electrique.

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. CARACTERISTIQUES 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 :

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.

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.
 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).

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- Definition

 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

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

 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.

 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 MATERIEL

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 date de lancement,
microcontrôleur, et le nombres de pins d’entrées analogiques et numériques.

Lancee Numerique 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

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
Arduno 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

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. Materiels 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 (mmicrocontrô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.

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 l'on communique à quelqu'un avec
un talkie-walkie. L'un parle pendant que l'autre écoute. Nous n'utiliserons pas ce type de2.6:
Figure communication.
Arduino Uno

 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.

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 entrees 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

 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 2 8 , 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 typ Max Unit

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

Tableau2.7: Alimentation
Figure2.6: Topolgie de la de la carte
carte Arduino
Arduino UNOUNO
R3 R3

V. PROTECTION DE LA CARTE RDUINO

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 .
 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.
CHAPITRE 3: CONTROLE ET SURBEILLANCE DE LA VITESSE D’UN MOTEUR
EN FONCTION DE LA TEMPERATURE AVEC ARDUINO
 INTRODUCTION:

Dans ce chapiter, on va décrir 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-eau, 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.

VIII. Mareriels
i. Capteur de temperature LM35DZ
i.1. A propos du capteur

 Le LM35 est l'un des capteur 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 extremes.
 Echelle: 10mV/°C.
 Clibre pour les degres Celsius: 0mV a 0° C, 1000mV a 100 °C.
 Laison de donnee: Analogique.
 Fiable impedence de sortie.
 Faible courant d’alimentation(60uA).
 Fiable 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, connecte a la borne ii. L
GND 3
negative de l'alimentation e s
Figure3.1: Brochage du capteur LM35DZ
autres materiels
Tableau3.1: Fonction des broches

Quantit
Materiels Description
e
Carte Arduino Arduino UNO R3 1
Capteur de LM35DZ acpteur 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.3: LM35DZ Figure3.4: Transistor 2N222

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

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

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

IX. Circuit

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 transitor est
efficace car il est utilisé comme interrupteur.
XI. Programme

Figure3.15: Programme
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]
{
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;
}
XII. Explication du programme
 Dans la premiere partie du programme on initialise les variables et leurs pins analogiques et numeriques
correspondants d'une facons permanante, c'est a dire qu'ils ne vont pas changer tout le long du
programme ce sont des variables globales .
 Concernant la deuxiemme partie du code on declare la fonction setup() qui utilisee pour initialiser les
variables locales. C'est une fonction qui n'est executee qu'une seule fois et qui ne renvoie pas de valeur-
void-.Dans la fontion setup(), on a fait appel a la fonction pinMode() qui permet de configurer comme
entree ou sortie les parametre declares-dans notre code on a declarer les variables mot et led comme
sorties et temPin comme entree-.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 troisieme partie de ce programme commence par la fonction loop()-boucle en aglais- fait exactement
ce que son nom sugge et s'execute en boucle sans fin, permettent au programme de s'executer et de
repondre, elle est utilise pour controler activement la carte Arduino et ne renvoie pas elle aussi aucune
valeur . Au sein de cette derniere, on a delarer 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 etudier les cas.
Dans le premier cas -if(temp,tempMin)- si cette instruction est realise la valeur de la vitesse du moteur
va egale a 0.Apres on a declarer l'instruction Apres on a declarer l'instruction
analogWrite(mot,motSpeed), qui va generer une onde cerree stable avec un"duty cycle"-Fraction de la
periode ou la broche est au niveau haut-de longeur specifiee -en purcentage-, jusqu'a l'appel suivant de
l'instruction analogWrite(ou bien encore l'appel a l'instruction digitalRead sur la meme broche). la
fraquence de l'onde PWM est approximativement de 490Hz. Apre on affecte la valeur 0 a la variable
motLCD et ensite en fait appel a la fonction digitalWrite(mot,LOW) qui envoie une valeur LOW au
pin digital (broche numerique) preconfigure comme sortie, puisque le pin a ete configure comme
OUTPUT avec la fonction pinMode(), son voltage s'etablit 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 egale a la valeur du variable temp ainsi que la valeur
novelle de la vitesse du moteur va egale a 5 fois la valeur anciene qui est implicitement la valeur de du
varible temp. Apres on a declarer l'instruction analogWrite(mot,motSpeed).Pour le troisieme cas -
if(temp>tempMax)-, on fait appel encore une fois a la fonction digitalWrite(led,HIGH) qui est aussi
configure comme un OUTPUT c'est a dire son voltage s'etablit dans la valeur 5V. Pour le 4eme cas-
else-, la led sera etteinte.
  Pour les 5 lignes du codes qui suit, le programme va ecrire la valeur du variable temp et la vitesse du
moteur avec un decalge de 2000 ms.
 Dnas les trois lignes dernieres du code, on va convertir la temperature capter en degree Celisius, affecter
la valeur capter par analogRead(tempPin) au variable temp,et enfin faire renvoiyer la valeur
temp*0.48828125.
XIII. Resulats de mesure

Figure3.16:Resultats de mesure
XIV. Conclusion

Apres avoir realiser cette application, il nous apparait calair que l’automatisation a jouer un major role dans le
developpement du secteur industriel. Comme il deja cite précédemment les automates programmables
industriels couts une somme importante d’argent, d’ou l’Arduino est venu comme un alternatif qui nous a aider
realise cette application d’automatisation industrielle avec des outiels qui cout pas cher et que tout le monde
peut trouver facilement afin d’arrive a realise un systeme d’automatisation industriel qui resemble a celui qu’on
trouve dans le monde industriel. Il est certain que l’Arduino est un outiel tres important qui represente
l’automation d’un point de vue innovant.