Mesurer une température avec un capteur LM35 et une carte Arduino / Genuino

Attention c'est chaud !

Image d'entête

par skywodd | | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino Analog Capteur LM35 Température

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.


Dans ce tutoriel, nous allons apprendre ensemble à mesurer des températures au moyen d'un capteur LM35 et d'une carte Arduino / Genuino. Nous verrons d'abord comment fonctionne ce capteur, puis comment l'utiliser. En bonus, nous verrons comment améliorer la précision de la mesure de température. Pour finir, nous verrons comment mesurer des températures négatives sans se prendre la tête.

Sommaire

Bonjour à toutes et à tous !

Dans un précédent article, nous avons vu ensemble comment mesurer des tensions avec une carte Arduino / Genuino. Nous allons aujourd'hui mettre à profit ces nouvelles connaissances en mesurant la température ambiante d'une pièce au moyen d'un capteur de température analogique LM35.

Qu'est-ce qu’un capteur LM35 ?

Brochage d'un capteur LM35

Brochage du 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 d'un capteur LM35

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.

N.B. On verra en bonus qu'il y a une astuce pour contourner le problème.

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 pour exemple Arduino LM35

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.

Il existe plusieurs versions de LM35

Capture d'écran des différentes versions de LM35

Les différentes versions de LM35 disponibles

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.

Ne vous trompez pas de référence lors de l'achat ;)

N.B. Beaucoup de vendeurs écoulent de vieux stocks de LM35D. Par conséquent, si la référence CZ ou CAZ n'est pas précisée, c'est qu'il s'agit à coup sûr d'un DZ.

PS Devinez quelle référence j'ai achetée initialement pour faire ce tutoriel, oui vous avez vu juste, le LM35DZ. L'erreur est humaine comme on dit.

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

Vue schématique du montage

Vue prototypage du montage de l'exemple Arduino LM35

Vue prototypage du montage

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.

Montage de l'exemple Arduino LM35

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
2
3
void setup() {
  Serial.begin(9600);
}

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

1
2
3
4
5
6
7
8
void loop() {
  int valeur_brute = analogRead(A0);

  float temperature_celcius = valeur_brute * (5.0 / 1023.0 * 100.0);

  Serial.println(temperature_celcius);
  delay(250);
}

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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
 * Code d'exemple pour le capteur LM35 (2°C ~ +110°C).
 */

// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

  // Initialise la communication avec le PC
  Serial.begin(9600);
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
  
  // Mesure la tension sur la broche A0
  int valeur_brute = analogRead(A0);
  
  // Transforme la mesure (nombre entier) en température via un produit en croix
  float temperature_celcius = valeur_brute * (5.0 / 1023.0 * 100.0);
  
  // Envoi la mesure au PC pour affichage et attends 250ms
  Serial.println(temperature_celcius);
  delay(250);
}

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 de l'exemple Arduino LM35

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.

PS Evitez de mettre le montage au four à 120°C pour tester les hautes températures, ce n'est pas une pizza ;) De même, évitez de mettre le montage au congélateur, l'électronique de la carte Arduino n'apprécie pas énormément l'humidité.

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
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 * Code d'exemple pour le capteur LM35 (2°C ~ +110°C) avec une meilleure précision.
 */

// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

  // Initialise la communication avec le PC
  Serial.begin(9600);
  
  // Améliore la précision de la mesure en réduisant la plage de mesure
  analogReference(INTERNAL); // Pour Arduino UNO
  // analogReference(INTERNAL1V1); // Pour Arduino Mega2560
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
  
  // Mesure la tension sur la broche A0
  int valeur_brute = analogRead(A0);
  
  // Transforme la mesure (nombre entier) en température via un produit en croix
  float temperature_celcius = valeur_brute * (1.1 / 1023.0 * 100.0);
  
  // Envoi la mesure au PC pour affichage et attends 250ms
  Serial.println(temperature_celcius);
  delay(250);
}

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 pour exemple Arduino LM35 (températures négatives)

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 de l'exemple Arduino LM35 (températures négatives)

Vue schématique du montage

Vue prototypage du montage de l'exemple Arduino LM35 (températures négatives)

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.

Montage de l'exemple Arduino LM35 (températures négatives)

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 ?

Astuce/montage pour mesurer des températures négatives avec un capteur LM35 et une alimentation simple

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
2
3
void setup() {
  Serial.begin(9600);
}

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

1
2
3
4
5
6
7
8
9
void loop() {
  int valeur_brute = analogRead(A0);
  int valeur_offset = analogRead(A1);

  float temperature_celcius = (valeur_brute - valeur_offset) * (5.0 / 1023.0 * 100.0);

  Serial.println(temperature_celcius);
  delay(250);
}

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
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
 * Code d'exemple pour le capteur LM35 avec support des températures négatives (-40°C ~ +110°C).
 */

// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

  // Initialise la communication avec le PC
  Serial.begin(9600);
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
  
  // Mesure la tension sur la broche A0 (sortie capteur) et A1 (référence du point zéro)
  int valeur_brute = analogRead(A0);
  int valeur_offset = analogRead(A1);
  
  // Transforme la mesure (nombre entier) en température via un produit en croix
  float temperature_celcius = (valeur_brute - valeur_offset) * (5.0 / 1023.0 * 100.0);
  
  // Envoi la mesure au PC pour affichage et attends 250ms
  Serial.println(temperature_celcius);
  delay(250);
}

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 de l'exemple Arduino LM35 (températures négatives)

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.