Capteur de température analogique LM35 avec Arduino

Dans ce tutoriel, vous apprendrez à utiliser un  capteur de température analogique LM35  avec Arduino. J’ai inclus un schéma de câblage et des exemples de codes pour vous aider à démarrer !

Dans la première partie de cet article, vous trouverez les spécifications et le brochage du LM35. Ensuite, nous verrons comment connecter le capteur à l’Arduino.

Le premier exemple de code peut être utilisé pour prendre des mesures de température à partir du capteur et afficher les résultats dans le moniteur série. Dans le deuxième exemple, je vais vous montrer comment utiliser la tension de référence intégrée de 1,1 V de l’Arduino pour obtenir des lectures plus précises. Enfin, nous verrons comment afficher la température sur un  LCD I2C  pour créer un thermomètre autonome.

Si vous souhaitez en savoir plus sur les autres capteurs de température, consultez les articles ci-dessous.

Composants matériels

Logiciel

À propos du LM35

Le LM35 est un capteur de température centigrade de précision peu coûteux fabriqué par  Texas Instruments . 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 réglage externe pour fournir des précisions de ± 0,5 ° C à température ambiante et de ± 1 ° C sur la plage de températures 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. Donc, si cela est nécessaire pour votre projet, je vous recommande d’utiliser le DS18B20 ou le TMP36 à la place. Le TMP36 d’Analog Devices est très similaire au LM35 et peut lire des températures de -40°C à 125°C sans aucun composant externe.

Vous pouvez trouver un tutoriel dédié pour le TMP36 et le DS18B20 ici :

• Capteur de température analogique TMP36 avec tutoriel Arduino
• Le guide complet des capteurs de température numériques DS18B20 avec Arduino

Le facteur d’échelle de sortie du LM35 est de 10 mV/°C et il fournit une tension de sortie de 250 mV à 25°C (voir la figure ci-dessous).

Tension de sortie du LM35 en mV en fonction de la température

Brochage LM35

Le LM35 est disponible en 4 boîtiers différents, mais le type le plus courant est le boîtier de transistor TO-92 à 3 broches.

Notez que la broche 1 (+V _S ) est la broche la plus à gauche lorsque le côté plat du capteur (avec le texte imprimé dessus) est tourné vers vous.

Vous trouverez les spécifications du LM35 dans le tableau ci-dessous.

Spécifications du capteur de température analogique LM35

Pour plus d’informations, vous pouvez également consulter la fiche technique ici:

Câblage – Connexion du capteur de température analogique LM35 à Arduino

La connexion d’un LM35 à l’Arduino est très simple car il suffit de connecter 3 broches. Commencez par connecter la broche +V _S  à la sortie 5 V de l’Arduino et la broche GND à la masse.

Ensuite, connectez la broche du milieu (V _OUT ) à l’une des entrées analogiques de l’Arduino. Dans ce cas, j’ai utilisé la broche d’entrée analogique A0.

Capteur de température analogique LM35 avec schéma de câblage Arduino Uno

avec V _OUT  en millivolt (mV). Donc si la sortie du capteur est de 750 mV, la température est de 75°C.

Comme vous pouvez le voir dans le schéma de câblage ci-dessus, la sortie du LM35 est connectée à l’une des entrées analogiques de l’Arduino. La valeur de cette entrée analogique peut être lue avec la fonction  analogRead() . Cependant, cette fonction ne renverra pas réellement la tension de sortie du capteur.

Les cartes Arduino contiennent un convertisseur analogique-numérique (ADC) multicanal 10 bits, qui mappe les tensions d’entrée entre 0 et la tension de fonctionnement (5 V ou 3,3 V) en valeurs entières entre 0 et 1023. Sur un Arduino Uno, par exemple , cela donne une résolution entre les lectures de 5 volts / 1024 unités ou 0,0049 volts (4,9 mV) par unité.

Ainsi, si vous utilisez analogRead() pour lire la tension sur l’une des entrées analogiques de l’Arduino, vous obtiendrez une valeur comprise entre 0 et 1023.

Pour reconvertir cette valeur en tension de sortie du capteur, vous pouvez utiliser :

V _OUT  = lecture de ADC * (Vref / 1024)

Nous utiliserons ces formules dans les exemples de code ci-dessous.

Capteur de température analogique LM35 avec exemple de code Arduino

Avec l’exemple de code suivant, vous pouvez lire la température d’un capteur LM35 et l’afficher dans le moniteur série.

Vous pouvez télécharger l’exemple de code sur votre Arduino à l’aide de l’  IDE Arduino .

Pour copier le code, cliquez sur le bouton dans le coin supérieur droit du champ de code.

/* Capteur de température analogique LM35 avec exemple de code Arduino. Plus d'infos : https://www.makerguides.com */

// Définir à quelle broche de l'Arduino la sortie du LM35 est connectée :
#définir capteurPin A0

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
}

boucle vide() {
  // Obtenez une lecture du capteur de température :
  int lecture = analogRead(sensorPin);

  // Convertit la lecture en tension :
  tension flottante = lecture * (5000/1024.0);

  // Convertit la tension en température en degré Celsius :
  température flotteur = tension / 10 ;

  // Imprime la température dans le Serial Monitor :
  Serial.print(température);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.println("C");

  retard(1000); // attend une seconde entre les lectures
}

Vous devriez voir la sortie suivante dans le moniteur série :

Assurez-vous que le débit en bauds du moniteur série est également défini sur 9600.

Comment fonctionne le code

Tout d’abord, j’ai défini à quelle broche de l’Arduino la broche V _OUT  du capteur est connectée. Dans ce cas, nous avons utilisé la broche analogique A0. L’instruction  #define  peut être utilisée pour donner un nom à une valeur constante. Le compilateur remplacera toutes les références à cette constante par la valeur définie lors de la compilation du programme. Ainsi, partout où vous mentionnez  sensorPin, le compilateur le remplacera par A0 lorsque le programme sera compilé.

// Définir à quelle broche de l'Arduino la sortie du LM35 est connectée :
#définir capteurPin A0

Dans la section de configuration du code, nous commençons la communication série à un débit en bauds de 9600.

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);
}

  // Obtenez une lecture du capteur de température :
  int lecture = analogRead(sensorPin);

Ensuite, nous utilisons les formules que j’ai mentionnées plus tôt dans l’article pour convertir la lecture en tension puis en température.

  // Convertit la lecture en tension :
  tension flottante = lecture * (5000/1024.0);

  // Convertit la tension en température en degré Celsius :
  température flotteur = tension / 10 ;

Enfin, les résultats sont imprimés dans le Serial Monitor :

  // Imprime la température dans le Serial Monitor :
  Serial.print(température);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.println("C");

Améliorer la précision des lectures

Parce que nous avons utilisé la tension de référence par défaut de l’Arduino pour l’entrée analogique (c’est-à-dire la valeur utilisée comme haut de la plage d’entrée), la résolution maximale que nous obtenons de l’ADC est de 5000/1024 = 4,88 mV ou 0,49°C.

Si nous voulons une plus grande précision, nous pouvons utiliser la référence 1,1 V intégrée de l’Arduino à la place. Cette tension de référence peut être modifiée à l’aide de la fonction  analogReference() .

Avec 1,1 V comme tension de référence, on obtient une résolution de 1100/1024 = 1,07 mV ou 0,11°C. Notez que cela limite la plage de température que nous pouvons mesurer à 0 à 110 degrés Celsius.

J’ai mis en surbrillance les lignes que vous devez ajouter/modifier dans le code ci-dessous :

/* Capteur de température analogique LM35 avec exemple de code Arduino. Plus d'infos : https://www.makerguides.com */

// Définir à quelle broche de l'Arduino la sortie du LM35 est connectée :
#définir capteurPin A0

void setup() {
  // Commencer la communication série à un débit en bauds de 9 600 :
  Série.begin(9600);

  // Définissez la tension de référence pour l'entrée analogique sur la référence intégrée de 1,1 V :
  analogReference(INTERNE);
}

boucle vide() {
  // Obtenez une lecture du capteur de température :
  int lecture = analogRead(sensorPin);

  // Convertit la lecture en tension :
  tension flottante = lecture * (1100 / 1024,0);

  // Convertit la tension en température en degré Celsius :
  température flotteur = tension / 10 ;

  // Imprime la température dans le Serial Monitor :
  Serial.print(température);
  Serial.print(" \xC2\xB0"); // affiche le symbole du degré
  Serial.println("C");

  retard(1000); // attend une seconde entre les lectures
}

Remarquez les incréments plus petits entre les lectures

LM35 avec LCD I2C et exemple de code Arduino

Si vous souhaitez créer un thermomètre autonome qui ne nécessite pas d’ordinateur, il peut être utile de savoir comment afficher les relevés de température sur un écran LCD.

Avec l’exemple de code ci-dessous, vous pouvez afficher les relevés de température sur un  écran LCD I2C de 16 × 2 caractères .

La connexion de l’écran LCD I2C est assez simple, comme vous pouvez le voir dans le schéma de câblage ci-dessous. Vous pouvez consulter mon tutoriel détaillé ci-dessous pour plus d’informations.

• Comment contrôler un LCD I2C de caractères avec Arduino

Si vous souhaitez plutôt utiliser un écran LCD non I2C standard, consultez cet article :

• • Comment utiliser un écran LCD 16 × 2 caractères avec Arduino

Recherchez maintenant ‘liquidcrystal_i2c’ et recherchez la bibliothèque de  Frank de Brabander . Sélectionnez la dernière version, puis cliquez sur Installer.

LM35 avec exemple de code LCD I2C

/* Capteur de température analogique LM35 avec LCD I2C et exemple de code Arduino. Plus d'infos : https://www.makerguides.com */

// Incluez les bibliothèques Arduino requises :
#include <LiquidCrystal_I2C.h>

// Crée une nouvelle instance de la classe LiquidCrystal_I2C :
LCD LiquidCrystal_I2C (0x27, 16, 2);

// Symbole de degré :
octet Degré[] = {
  B00111,
  B00101,
  B00111,
  B0000,
  B0000,
  B0000,
  B0000,
  B00000
};

// Définir à quelle broche de l'Arduino la sortie du LM35 est connectée :
#définir capteurPin A0

void setup() {
  // Démarrez l'écran LCD et allumez le rétroéclairage :
  lcd.init();
  LCD rétro-éclairage();

  // Crée un personnage personnalisé :
  lcd.createChar(0, Degré);
}

boucle vide() {
  // Obtenez une lecture du capteur de température :
  int lecture = analogRead(sensorPin);

  // Convertit la lecture en tension :
  tension flottante = lecture * (5000/1024.0);

  // Convertit la tension en température en degré Celsius :
  température flotteur = tension / 10 ;

  // Imprimer la température sur l'écran LCD ;
  lcd.setCursor(0, 0);
  lcd.print("Température :");
  lcd.setCursor(0, 1);
  lcd.print(température);
  lcd.write(0); // imprime le caractère personnalisé 
  lcd.print("C"); 

  retard(1000); // assiste une seconde entre les lectures 
}

Vous devriez voir la sortie suivante sur l’écran LCD :

Conclusion

Dans ce tutoriel, je vous ai montré comment utiliser un capteur de température analogique LM35 avec Arduino. J’espère que vous l’avez trouvé utile et informatif. Si c’est le cas,  partagez cet article  avec un ami qui aime aussi l’électronique et la fabrication d’objets.

J’aimerais savoir quels projets vous envisagez de construire (ou avez déjà construit) avec ce capteur. Si vous avez des questions, des suggestions ou si vous pensez qu’il manque des choses dans ce tutoriel,  veuillez laisser un commentaire ci-dessous .

Notez que les commentaires sont conservés pour modération afin d’éviter les spams.