‫الجمهورية الجزائرية الديمقراطية الشعبية‬

‫وزارة التعليم العالي والبحث العلمي‬

‫جامعة محمد خيضر بسكرة‬

‫الكلية‪ :‬علوم وتكنولوجيا!‬
‫القسم‪ :‬الهندسة الكهربائية‬
‫التخصص‪ :‬الكتروميكانيك!‬
‫المقياس‪capteur :‬‬

‫‪TP01 :‬‬

‫‪mesure de température‬‬
‫‪avec arduino‬‬

‫‪Professeur:‬‬ ‫‪Étudiant :‬‬

‫‪Dr.saadi ramzi‬‬ ‫‪Messaoudi aimen saber‬‬

 Qu'est-ce qu’un capteur LM35 ?

Le capteur de température LM35 est un capteur analogique de température fabriqué par Texas

Instruments. Il est extrêmement populaire en électronique, car précis, peu couteux, très simple
d'utilisation et d'une fiabilité à toute épreuve.
Le capteur de température LM35 est capable de mesurer des températures allant de -55°C à
+150°C dans sa version la plus précise et avec le montage adéquat, de quoi mesurer n'importe
quelle température.
N.B. Les versions grand publiques sont capables de mesurer des températures comprises
entre -40°C et +110°C.
La sortie analogique du capteur est proportionnelle à la température. Il suffit de mesurer la
tension en sortie du capteur pour en déduire la température. Chaque degré Celsius correspond
à une tension de +10mV.
Dans ce tutoriel, nous étudierons deux montages : un très simple permettant de mesurer des
températures positives uniquement (de 2°C à 110°C) et un second plus complexe permettant
de mesurer des températures de -40°C à +110°C.
Le capteur LM35 supporte des températures assez extrêmes (jusqu'à -55°C / +150°C), mais il
n'en est pas de même pour les cartes Arduino.
Si vous soumettez une carte Arduino "classique" à ces températures extrêmes, elle va
purement et simplement cesser de fonctionner ou se dégrader très rapidement. Cela est
valable pour les cartes Arduino, mais aussi pour tous autres circuits électroniques fabriqués
suivant les standards "grand public" (et non "industriels").
Pour information, les gammes de températures classiques en électronique sont les suivantes :
 grand public : 0°C ~ 70°C
 industrie : -40°C ~ 85°C
 militaire : -55°C ~ 125°C
Une des grandes forces du capteur LM35, qui fait sa popularité, c'est sa précalibration en
sortie d'usine. Tous les capteurs LM35 sont calibrés en degré Celsius lors de la fabrication.
Cela signifie que vous n'avez absolument rien à faire pour calibrer le capteur, il l'est déjà au
moment où vous le sortez de son sachet !

Courbes de précision des différentes versions de LM35

La précision garantie par le fabricant est de +/-1°C à 25°C et +/-1.5°C à -55°C ou +150°C
pour la version la moins précise, ce qui est largement suffisant pour la plupart des
applications. La version plus précise du LM35 (nommée "LM35A") a une précision garantie
de +/-0.5°C à 25°C et +/-1°C à -55°C ou +150°C.
Une autre des grandes forces du capteur LM35, c'est sa linéarité exemplaire : moins de 1°C
d'erreur sur la plage complète de -55°C à +150°C. Comme chaque degré Celsius correspond à
10mV (soit 0.01 volt) et que la sortie du capteur est (quasi) parfaitement linéaire, convertir
une mesure en température se résume à faire un bête produit en croix.
Pour en finir avec les compliments, le capteur LM35 fonctionne avec n'importe quelle tension
d'alimentation comprise entre 4 volts et 30 volts, ce qui permet de l'utiliser dans virtuellement
n'importe quel montage numérique ou analogique.
Passons maintenant aux points négatifs, ceux qui fâchent. Le capteur LM35 ne fonctionne pas
en dessous de 4 volts, donc oubliez l'utilisation d'un LM35 avec des cartes Arduino 3.3 volts
(Due, Zero, etc), sans alimentation 5 volts externe, ça ne marche pas.
N.B. Le capteur LM35 peut être utilisé avec une entrée analogique 3v3, car 150°C = 1,5V,
cependant, une alimentation 5v reste obligatoire pour que le capteur fonctionne.
Autre souci, le capteur LM35 nécessite une alimentation négative pour mesurer des
températures en dessous de 0°C. La sortie est proportionnelle à la température, par
conséquent -10°C équivaut à -0,1 volt. De fait, avec une simple alimentation 5v, comme celle
des cartes Arduino, il n'est possible de mesurer que des températures positives.

Mesurer une température avec un capteur LM35

Maintenant que vous savez tout sur le capteur LM35, il est grand temps de le mettre à
l'oeuvre. Pour cela, nous allons faire un petit montage de démonstration très simple.
Le but de ce montage sera de tout simplement mesurer la température ambiante de l'atelier et
d'envoyer la température en degré Celsius vers l'ordinateur via le câble USB.
Le montage de démonstration

Matériel nécessaire
Pour réaliser ce montage, il va nous falloir :
 Une carte Arduino UNO (et son câble USB),
 Un capteur LM35 (attention, il existe plusieurs versions, voir l'encadré ci-dessous),
 Un condensateur de 100nF (optionnel, mais recommandé),
 Une plaque d'essai et des fils pour câbler notre montage.
 différentes versions de LM35  :

Pour faire simple, si on s'intéresse uniquement aux LM35 "à pattes" (boitier TO-92 pour les
intimes), il existe trois versions :
 Le LM35DZ, capable de mesurer des températures de 0 à 100°C avec une précision de
1.5°C aux extrêmes.
 Le LM35CZ, capable de mesurer des températures de -40 à 110°C avec une précision
de 1.5°C aux extrêmes.
 Le LM35CAZ, capable de mesurer des températures de -40 à 110°C avec une
précision de 1°C aux extrêmes.

Vue schématique du montage de l'exemple Arduino LM35 :

Pour commencer notre montage, nous allons câbler la broche VCC du capteur à l'alimentation
5V de la carte Arduino au moyen d'un fil. On fait ensuite de même avec la broche GND du
capteur qui vient se câbler sur la broche GND de la carte Arduino.
Pour faire les choses bien (parce que oui, on aime faire les choses bien), on va venir câbler un
condensateur de 100nF (un condensateur de découplage en termes techniques) entre les
broches VCC et GND du capteur. Il faut que le condensateur soit câblé le plus près possible
du capteur pour être efficace.

Le montage fini
On achève ensuite le circuit en reliant la sortie du capteur à la broche A0 de la carte Arduino
avec un fil.
Le code de démonstration
Maintenant que nous avons notre montage, passons au code !
Le but de notre code va être de :
1. Lire la tension sur la broche A0
2. Convertir la valeur mesurée en une température (pour l'affichage)
3. Envoyer la valeur au PC (pour l'affichage)
4. Recommencer au point 1.
Pour réaliser ce morceau code, nous allons utiliser la fonction analogRead() vue dans un
précédent tutoriel.

1 void setup() {
2 Serial.begin(9600);
3}

Nous allons commencer notre programme de démonstration avec la fonction setup() qui va

simplement initialiser la communication avec le PC.
PS Ne cherchez pas à comprendre comment utiliser de  Serial.begin() pour le moment, cela

fera l'objet d'un futur tutoriel 

void loop() {
1
int valeur_brute = analogRead(A0);
2
3
float temperature_celcius = valeur_brute * (5.0 / 1023.0 *
4
100.0);
5
6
Serial.println(temperature_celcius);
7
delay(250);
8
}

Dans la fonction loop(), nous allons faire trois choses :

1. Mesurer la tension sur la broche A0 avec analogRead().
2. Transformer le résultat de la mesure en un nombre à virgule (type float) en faisant un
simple produit en croix. Rappel : 5V = 5000mV = 1023 en sortie
de analogRead(), 10mV = 1°C, par conséquent, température = valeur_mesurée * (5.0 /
1023.0 * 100.0)
3. Envoyer la valeur au PC et attendre quelques millisecondes pour avoir le temps de lire
ce qui se passe côté PC.
N.B. On utilise valeur * (5.0 / 1023.0 * 100.0) dans le calcul du produit en croix, car lors de
la compilation du programme, c'est le type des valeurs d'une opération qui définit le type du
résultat. Si on fait valeur * (5 / 1023 * 100) comme valeur, 5, 1023 et 100 sont des nombres
entiers, le résultat est un nombre entier, ce qui n'est pas notre but, nous voulons un calcul
avec des nombres à virgule. On utilise donc 5.0, 1023.0 et 100.0 pour forcer un calcul avec
des nombres à virgule.
N.B. On multiplie par 100 dans le calcul, car dans 5 volts (= 5000mV) il y a 100 fois 10mV
(= 1°C).
PS Je vous laisse faire la conversion en degrés Fahrenheit pour ceux que ça intéresse. La
formule est : fahrenheit = celcius * 1.8 + 32.
Le code complet avec commentaires :

/*
1
* Code d'exemple pour le capteur LM35 (2°C ~ +110°C).
2
*/
3
4
// Fonction setup(), appelée au démarrage de la carte Arduino
5
void setup() {
6
7
// Initialise la communication avec le PC
8
Serial.begin(9600);
9
}
10
11
// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est
12
alimentée
13
void loop() {
14
15
// Mesure la tension sur la broche A0
16
int valeur_brute = analogRead(A0);
17
18
// Transforme la mesure (nombre entier) en température via un produit en croix
19
float temperature_celcius = valeur_brute * (5.0 / 1023.0 * 100.0);
20
21
// Envoi la mesure au PC pour affichage et attends 250ms
22
Serial.println(temperature_celcius);
23
delay(250);
24
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de

téléchargement en .zip contient le projet Arduino prêt à l'emploi).
 Le résultat

Capture d'écran du moniteur série

Après avoir envoyé le programme dans la carte Arduino, en ouvrant le moniteur série
(onglet outils), puis en sélectionnant la bonne vitesse de communication (ici 9600 bauds),
vous devriez voir apparaitre en temps réel la température en sortie du capteur.
Si votre montage est correct, en pinçant le capteur ou en soufflant dessus, les valeurs dans le
moniteur série doivent normalement changer.

Bonus : améliorer la précision de la mesure

Comme on a pu le voir dans un précédent tutoriel, pour qu'un convertisseur analogique /
numérique puisse faire son travail, il a besoin d'une tension maximum de référence. Cette
tension s'appelle AREF par convention.
Pouvoir choisir cette tension est très intéressant, car cela permet de réduire la plage de tension
de mesure et donc d'améliorer drastiquement la précision des mesures.
Si on mesure un signal analogique toujours compris entre 0 volt et 1,5 volt, comme c'est le
cas avec un capteur LM35 par exemple, il est dommage d'avoir une référence à 5v, car plus
de la moitié des points de mesure ne sont jamais utilisés.
Dans le cas d'un LM35 de gammes "grand publique" ou "industrielle", la tension maximum
est même de 1.1v (= 110°C), avoir une tension de référence à 5v est donc dramatique pour la
précision de la mesure. Pour rappel, 5 volts / 1024 points (10 bits) = 4.89mV par point.
Les microcontrôleurs, comme ceux utilisés dans les cartes Arduino, disposent généralement
d'une broche spéciale nommée AREF sur laquelle on peut venir injecter sa propre tension de
référence. Il est aussi possible d'utiliser une ou plusieurs tensions de référence interne en
fonction du microcontrôleur.
Avec une carte Arduino classique (Uno, Mega2560, etc.), il est possible de choisir la
référence de tension en utilisant la fonction analogReference().
Dans notre cas, plusieurs choix sont possibles :
 utiliser le mode EXTERNAL en reliant la broche AREF à la sortie +3V de la carte
Arduino,
 utiliser le mode INTERNAL (Arduino UNO) ou INTERNAL1V1 (Arduino
Mega2560).
L'utilisation du mode EXTERNAL et de la broche AREF a l'avantage d'être générique. Cela
fonctionne sur n'importe quelle carte Arduino classique. Cependant, la seule tension autre que
5 volts disponible sur une carte Arduino est de 3.3 volts. Or, 3.3 volts / 1024 points (10 bits)
= 3.23mV par point, c'est mieux, mais encore loin d'être parfait.
On pourrait utiliser un montage avec une diode zener sur la broche AREF pour générer une
tension stable de 1.1 volt, mais cela serait un peu complexe. Il est plus simple d'utiliser les
modes INTERNAL et INTERNAL1V1, qui permettent d'utiliser une tension de référence à
1.1 volt, interne au microcontrôleur. Cela ne fonctionne que sur certaines cartes Arduino
(UNO pour le mode INTERNAL et Mega2560 pour le mode INTERNAL1V1), mais cela a
l'avantage de ne demander aucune modification du montage de base.
En utilisant le code suivant avec le montage du chapitre précédent, vous devriez constater une
amélioration de la précision de la mesure :

1 /*
2 * Code d'exemple pour le capteur LM35 (2°C ~ +110°C) avec une meilleure précision.
3 */
4
5 // Fonction setup(), appelée au démarrage de la carte Arduino
6 void setup() {
7
8 // Initialise la communication avec le PC
9 Serial.begin(9600);
10
11 // Améliore la précision de la mesure en réduisant la plage de mesure
12 analogReference(INTERNAL); // Pour Arduino UNO
13 // analogReference(INTERNAL1V1); // Pour Arduino Mega2560
14 }
15
16 // Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est
17 alimentée
 void loop() {
18
19
// Mesure la tension sur la broche A0
20
int valeur_brute = analogRead(A0);
21
22
// Transforme la mesure (nombre entier) en température via un produit en croix
23
float temperature_celcius = valeur_brute * (1.1 / 1023.0 * 100.0);
24
25
// Envoi la mesure au PC pour affichage et attends 250ms
26
Serial.println(temperature_celcius);
27
delay(250);
28
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de

téléchargement en .zip contient le projet Arduino prêt à l'emploi).
N.B. L'appel à la fonction analogReference() doit être fait au démarrage avant de faire
le moindre appel à analogRead().
Le changement de référence est effectif après quelques millisecondes. Il est donc possible que
les premières mesures de tension après un changement de référence ne soient pas justes.
 Ne rien connecter sur la broche AREF si une tension de référence interne est utilisée
Tout est dans le titre, ne connectez rien à la broche AREF si une tension de référence interne
est utilisée.
Si vous connectez quelque chose sur la broche AREF sans être dans le mode EXTERNAL,
vous allez déclencher un court-circuit à l'intérieur du microcontrôleur, ce qui lui sera fatal.

Bonus : Mesurer des températures négatives

Mesurer des températures comprises entre 0°C et +110°C, c'est bien. Cependant, il arrive
régulièrement qu'on ait besoin de mesurer des températures négatives. Tout le monde n'habite
pas dans le sud (dommage).
Le montage
Afin de comprendre comment mesurer des températures négatives avec une carte Arduino,
nous allons reprendre le montage de démonstration du chapitre précédent et le modifier.
 Matériel nécessaire
Pour réaliser ce second montage, il va nous falloir :
 Une carte Arduino UNO (et son câble USB),
 Un capteur LM35 (attention, il faut bien prendre une version CZ ou CAZ, pas DZ !),
 Un condensateur de 100nF (optionnel, mais recommandé),
 Deux diodes 1N4148,
 Une résistance de 18K ohms (marron / gris / orange),
 Une plaque d'essai et des fils pour câbler notre montage.

Vue schématique du montage

 Vue prototypage du montage
Pour commencer notre second montage, nous allons câbler la broche VCC du capteur à
l'alimentation 5V de la carte Arduino au moyen d'un fil. On relie ensuite la broche GND du
capteur en série avec les deux diodes 1N4148, puis à la broche GND de la carte Arduino.
N.B. Les diodes sont polarisées ! Elles ont un "sens". Le trait noir sur la diode indique
l'emplacement de la barre verticale sur le schéma.
On continue le montage en reliant la broche GND du capteur (juste après les deux diodes), à
la broche A1 de la carte Arduino.
Toujours pour faire les choses bien, on va venir câbler un condensateur de 100nF entre les
broches VCC et GND du capteur. Comme pour le premier montage, il faut que le
condensateur soit câblé le plus près possible du capteur pour être efficace.

Le montage fini
On achève ensuite le circuit en reliant la sortie du capteur à la broche A0 de la carte Arduino
avec un fil et en câblant la résistance de 18K ohms entre la sortie du capteur et la
broche GND de la carte Arduino.
 Comment ça marche ?

Extrait de la documentation constructeur

Le principe est assez simple.
Les deux diodes 1N4148 induisent une chute de tension d'environ 0.6 volt à leur borne
chacune (c'est une caractéristique physique des diodes, appelée "Forward Voltage" dans les
documents techniques), soit 1.2 volt au total entre la masse réelle du montage et la
broche GND du capteur.
Avec une masse à 1.2 volt au niveau du capteur, il est possible pour le capteur d'aller en
dessous de "son" 0 volt vu qu'il n'est en réalité pas à 0 volt, mais à 1.2 volt.
Il y a cependant un petit souci avec ce montage : la tension aux bornes des diodes varie en
fonction de la température … Ce qui est embêtant pour un montage censé mesurer des
températures. C'est un comportement normal pour une diode, c'est même un comportement
qui est utilisé pour mesurer des températures. Sauf que dans notre cas, c'est un comportement
parasite.
L'astuce pour "annuler" cette variation de tension en fonction de la température consiste à
mesurer la tension au niveau de la broche GND du capteur, puis de corriger la mesure finale
en faisant une soustraction dans le code.
Le code
Pour réaliser ce second morceau code, nous allons reprendre le code du montage de
démonstration du chapitre précédent et lui apporter quelques modifications.

1 void setup() {
2 Serial.begin(9600);
3}

La partie setup() reste inchangée.
On notera seulement qu'il n'est pas possible d'utiliser l'astuce du analogReference() vu dans le
chapitre précédent avec ce montage, car nous allons mesurer des tensions entre 0 volt et ~3,5
volts (avec un signal centré autour de 2 volts).
 void loop() {
1
int valeur_brute = analogRead(A0);
2
int valeur_offset = analogRead(A1);
3
4
float temperature_celcius = (valeur_brute - valeur_offset) * (5.0 / 1023.0 *
5
100.0);
6
7
Serial.println(temperature_celcius);
8
delay(250);
9
}

Dans la fonction loop(), nous allons faire deux modifications:

1. Nous allons mesurer la tension sur la broche A1 avec analogRead() pour savoir de
combien la valeur brute doit être compensée.
2. Nous allons modifier le produit en croix pour que la valeur brute soit corrigée.
Le code complet avec commentaires :

1 /*
2 * Code d'exemple pour le capteur LM35 avec support des températures négatives (-40°C
3 ~ +110°C).
4 */
5
6 // Fonction setup(), appelée au démarrage de la carte Arduino
7 void setup() {
8
9 // Initialise la communication avec le PC
10 Serial.begin(9600);
11 }
12
13 // Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est
alimentée
14
void loop() {
15
16
// Mesure la tension sur la broche A0 (sortie capteur) et A1 (référence du point zéro)
17
int valeur_brute = analogRead(A0);
18
int valeur_offset = analogRead(A1);
19
20
// Transforme la mesure (nombre entier) en température via un produit en croix
21
float temperature_celcius = (valeur_brute - valeur_offset) * (5.0 / 1023.0 * 100.0);
22
// Envoi la mesure au PC pour affichage et attends 250ms
23
Serial.println(temperature_celcius);
24
delay(250);
25
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de

téléchargement en .zip contient le projet Arduino prêt à l'emploi).
Le résultat

Capture d'écran du moniteur série

Après avoir envoyé le programme dans la carte Arduino, en ouvrant le moniteur série
(onglet outils), puis en sélectionnant la bonne vitesse de communication (ici 9600 bauds),
vous devriez voir apparaitre en temps réel la température en sortie du capteur.
Si votre montage est correct, en plaçant le capteur au congélateur, les valeurs dans le
moniteur série doivent normalement changer et descendre en dessous de 0°C.

Conclusion
Ce tutoriel est désormais terminé.
Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les
réseaux sociaux et à soutenir le site si cela vous fait plaisir.