Mémoire de Projet 2022
Mémoire de Projet 2022
Mémoire de Projet 2022
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
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.
NOUS professeurs
Tous ceux qui nous ont aidés de près ou de loin pour la réalisation de ce travail
INTRODUCTION..................................................................................................................................................2
I. Historique.........................................................................................................................................................3
i. Aspect extérieur..........................................................................................................................................7
ii. Aspect interne …........................................................................................................................................8
i. Arduino-Prix: ........................................................................................................................16
ii. Matèriels et Logiciels derives................................................................................................17
iii. Matèriels et Logiciels libres...................................................................................................17
iv. Arduino et IoT.......................................................................................................................17
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
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.
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
Chapitre02: Dans ce chapitre on a étudié l'Arduino, les types des cartes, les microcontrôleurs utilises
Chapitre03: Ce chapitre est consacré à l'étude et la réalisation d'une application par l’Arduino qui est
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.
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
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.
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).
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 ..
7
VI. Les types des automates
i. Aspect extérieur
8
ii. Aspect interne
9
Figure1.4: Architecture materielle d’un API
10
VII. 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.
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, ...).
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:
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.
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).
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++.
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.
La barre apparaissant en haut s'appelle la barre de menus qui comprend cinq options
différentes comme suit :
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 :
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.
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.
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.
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
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
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
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.
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.
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
28
Fifure3.8: Fils de connection Figure3.9: Cable de connection Figure3.10: Moteur
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
}
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);
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
38
Liste des abréviations
API : Automate Programmable Industriel
SCADA F & G : Supervisory Control And Data Acquisition Fire & Gas
LD : Laser Disc
N /A : Numérique /Analogique
V : Volt
Ko : kilo ohm
°C : Celsius
μF : Micro farad
mm: millimetre
CC : Courant Continue
40