LM35 Arduino : capteur de température, branchement et code

Le LM35 est un capteur de température analogique bon marché à trois pattes qui convertit directement la température en une tension exprimée en degrés Celsius. Pour utiliser le LM35 avec Arduino, il ne faut ni bibliothèque ni protocole compliqué : tu relies la patte du milieu à une broche analogique, tu la lis avec analogRead() et tu obtiens la température avec une formule d'une ligne. Sa sortie augmente d'exactement 10 mV par degré, elle donne donc 250 mV à 25 °C et 1 V à 100 °C.

Dans ce guide, tu vas apprendre comment fonctionne le LM35, l'ordre de ses pattes et l'erreur d'inversion que presque tout le monde fait une fois, comment calculer les °C à partir de la valeur d'analogRead, comment rendre tes mesures plus de quatre fois plus fines grâce à la référence interne de 1,1 V de l'Arduino Uno et comment calmer les valeurs qui sautent en faisant une moyenne. Tu verras ensuite à quoi faire attention avec l'ESP32 et le Raspberry Pi Pico en 3,3 V, comment mesurer des températures négatives et quand choisir le LM35 plutôt que le DS18B20 ou le DHT11.

Qu'est-ce que le LM35 et comment fonctionne-t-il ?

À l'intérieur du LM35, deux transistors fonctionnent avec des densités de courant différentes. L'écart entre leurs tensions base-émetteur varie proportionnellement à la température absolue ; cette méthode s'appelle delta-VBE. Un amplificateur interne amplifie ce petit écart et le décale pour que la sortie vaille 0 V à 0 °C. Ainsi, contrairement aux capteurs en kelvins comme le LM335, tu n'as pas à soustraire une grosse tension constante : température (°C) = tension de sortie (mV) / 10. Le capteur est ajusté directement sur la galette de silicium pendant la fabrication, il ne demande donc aucun étalonnage supplémentaire et sa courbe est presque parfaitement droite ; sa non-linéarité typique n'est que de ±0,25 °C.

Le LM35 n'est pas un composant unique mais une famille. La lettre du suffixe fixe la plage de mesure et la précision garantie, et le Z final désigne le boîtier plastique TO-92. D'après la fiche technique, les versions en TO-92 plastique sont les LM35C, LM35CA et LM35D ; la plupart des pièces vendues sous le nom "LM35" dans les boutiques d'électronique sont en fait des LM35DZ. Ton capteur n'est donc très probablement garanti qu'entre 0 et 100 °C et peut se tromper jusqu'à ±1,5 °C à 25 °C, même si son erreur typique tourne autour de ±0,6 °C. Le marquage sur le composant t'indique lequel tu as.

Brochage du LM35 et l'erreur la plus fréquente : le branchement inversé

Face plate du LM35 tournée vers toi et pattes vers le bas, l'ordre de gauche à droite est : patte 1 +Vs (alimentation), patte 2 Vout (sortie) et patte 3 GND (masse). Comme le dessin de la fiche technique est une vue de dessous, beaucoup de gens l'inversent mentalement et le branchent à l'envers. Sur les modules LM35 vendus sur une petite carte, les broches sont généralement marquées VCC (ou +), OUT (ou S) et GND (ou −) ; dans ce cas, fie-toi à la sérigraphie de la carte.

Branchement du LM35 sur Arduino : Uno, ESP32 et Pico

De la valeur d'analogRead aux °C : la formule du LM35

Le convertisseur analogique-numérique (ADC) de l'Arduino Uno travaille sur 10 bits : il découpe la plage entre 0 V et la tension de référence en 1024 pas et te renvoie un nombre de 0 à 1023. Comme la référence vaut 5 V par défaut, chaque pas correspond à 5 / 1024 = 4,88 mV. Tu convertis d'abord la valeur brute en tension, puis la tension en température : tension = brut × 5,0 / 1024 et température = tension × 100. En combinant les deux, température ≈ brut × 0,488. Certains exemples utilisent 1023 au lieu de 1024 ; l'écart est d'un millième et négligeable face à l'erreur propre du LM35, mais la valeur correcte est 1024. Pour comprendre l'ADC plus en détail, consulte l'article sur la conversion analogique-numérique (ADC).

Regarde bien le tableau : à température ambiante, l'ADC ne produit qu'un nombre autour de 50, et un seul pas fait varier la température d'environ 0,5 °C. Voilà pourquoi ta mesure oscille entre 24,9 et 25,4 ; le capteur n'est pas défectueux, c'est simplement la résolution de la référence de 5 V. Nous allons corriger cela juste après avec la référence interne.

Première mesure, étape par étape

1. Enfiche le LM35 sur la breadboard ; face plate vers toi, relie la patte de gauche au 5V et celle de droite au GND.
2. Relie la patte du milieu (Vout) à A0 avec un fil de liaison. Si tu en as un, ajoute un condensateur de 0,1 µF entre +Vs et GND.
3. Branche l'Arduino en USB et touche le capteur au bout de quelques secondes : s'il est à température ambiante, tout va bien ; s'il est brûlant, il est branché à l'envers.
4. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
5. Prends le capteur entre tes doigts ; la valeur doit monter lentement, puis redescendre quand tu le lâches.

1const int LM35_PIN = A0;   // LM35 orta bacak (Vout) / LM35 middle leg (Vout)
2
3void setup() {
4  Serial.begin(9600);
5}
6
7void loop() {
8  int raw = analogRead(LM35_PIN);          // 0–1023 ham değer / raw value 0–1023
9  float voltage = raw * 5.0 / 1024.0;      // 5 V referansla volta çevir / convert to volts (5 V reference)
10  float tempC = voltage * 100.0;           // 10 mV/°C: 0,25 V = 25 °C / 0.25 V = 25 °C
11
12  Serial.print(F("Ham / Raw: "));
13  Serial.print(raw);
14  Serial.print(F("  Gerilim / Voltage: "));
15  Serial.print(voltage, 3);
16  Serial.print(F(" V  Sicaklik / Temp: "));
17  Serial.print(tempC, 1);
18  Serial.println(F(" C"));
19  delay(1000);
20}

Chaque seconde, le code lit la valeur brute sur A0, la convertit d'abord en tension puis en température, et affiche les trois dans le moniteur série. Afficher la valeur brute aide beaucoup au débogage : si elle reste à 0, aucune tension n'arrive de Vout ; si elle est proche de 1023, la broche analogique est reliée au 5 V par erreur ; si elle saute au hasard, A0 est en l'air. Écrire les textes fixes dans la macro F() économise les 2 Ko de RAM de l'Uno. Tu trouveras d'autres astuces dans l'article sur l'utilisation du moniteur série Arduino.

Plus de résolution avec la référence interne de 1,1 V

La référence de 5 V pose deux problèmes. Le premier est la résolution grossière que tu viens de voir. Le second est plus sournois : le 5 V fourni par l'USB se situe souvent entre 4,7 et 5,1 V, et comme ton code indique 5,0, l'écart se retrouve directement dans la température. Par exemple, si ta carte tourne en réalité sous 4,8 V, tu liras 26 °C au lieu de 25 °C, et quand le port USB de ton ordinateur faiblit sous la charge, la température semble varier toute seule. La solution consiste à utiliser la référence interne de 1,1 V de l'ATmega328P des Arduino Uno et Nano. Après analogReference(INTERNAL), chaque pas vaut 1,1 / 1024 = 1,07 mV, soit environ 0,11 °C. En contrepartie, tu ne peux mesurer que jusqu'à 1,1 V, c'est-à-dire 110 °C, ce qui suffit largement pour la plage 0–100 °C du LM35DZ.

La référence de 1,1 V ne vaut pas exactement 1,1 V sur chaque puce ; d'après la fiche technique de l'ATmega328P, elle peut se situer entre 1,0 et 1,2 V. Sans étalonnage, cela représente une erreur d'échelle pouvant atteindre 9 %. La correction est simple : téléverse le code ci-dessous, mesure au multimètre la tension entre la broche AREF et GND, puis inscris la valeur dans la constante VREF (par exemple const float VREF = 1.083;). Il suffit de le faire une fois par carte, et le résultat reste valable. Le code fait aussi la moyenne de 32 mesures à chaque lecture :

1const int LM35_PIN = A0;
2const float VREF = 1.1;     // AREF'te ölçtüğün değeri yaz (ör. 1.083) / write the voltage you measured on AREF (e.g. 1.083)
3const int SAMPLES = 32;     // ortalama için ölçüm sayısı / number of samples to average
4
5void setup() {
6  Serial.begin(9600);
7  analogReference(INTERNAL);        // Uno/Nano: 1,1 V dahili referans / 1.1 V internal reference
8  for (int i = 0; i < 5; i++) {     // referans değişti, ilk okumaları at / discard the first readings after switching
9    analogRead(LM35_PIN);
10    delay(10);
11  }
12}
13
14float readTempC() {
15  long sum = 0;
16  for (int i = 0; i < SAMPLES; i++) {
17    sum += analogRead(LM35_PIN);
18    delay(2);
19  }
20  float raw = sum / (float)SAMPLES;       // ortalama ham değer / average raw value
21  return raw * VREF / 1024.0 * 100.0;     // her basamak ~0,107 °C / each step is ~0.107 °C
22}
23
24void loop() {
25  float t = readTempC();
26  Serial.print(F("Sicaklik / Temp: "));
27  Serial.print(t, 2);
28  Serial.println(F(" C"));
29  if (t > 108.0) {
30    Serial.println(F("Uyari: 1,1 V sinirina yakin / Warning: close to the 1.1 V limit"));
31  }
32  delay(1000);
33}

Faire la moyenne et réduire le bruit

Une seule lecture d'analogRead peut varier d'un ou deux pas à cause des parasites sur les fils et de l'ondulation de l'alimentation. La solution la plus simple et la plus efficace consiste à faire la moyenne de plusieurs mesures : le bruit aléatoire diminue avec la racine carrée du nombre d'échantillons, donc la moyenne de 16 mesures le divise par quatre et celle de 64 par huit. Comme la température évolue lentement, des dizaines de mesures prises en quelques millisecondes ne te font perdre aucun temps. Pour une courbe encore plus lisse, utilise un filtre exponentiel : filtré = filtré + 0,1 × (nouveau − filtré). Ce filtre ne prend en compte que 10 % de chaque nouvelle mesure et ne garde qu'une seule variable en mémoire. Nous comparons d'autres méthodes, comme la moyenne glissante et la médiane, dans l'article sur le filtrage des données de capteurs.

• Ignore la première lecture après un changement de canal : si tu lis plusieurs capteurs analogiques, le condensateur d'échantillonnage de l'ADC garde brièvement la tension du canal précédent ; lis la même broche deux fois et ignore le premier résultat.
• Ramène le GND du capteur directement sur la broche GND de l'Arduino : si le courant d'un relais, d'un moteur ou d'un ruban LED passe par le même fil de masse, des décalages de quelques millivolts apparaissent, et sur le LM35, 10 mV valent un degré.
• Garde le câble court et loin des fils de puissance : les longs fils non blindés se comportent comme des antennes ; utilise si besoin un câble torsadé ou blindé.
• Éloigne le capteur des sources de chaleur : un LM35 collé à un régulateur de tension, à un module ESP32 ou à un relais mesure la température de la carte, pas celle de la pièce.
• Étalonne le décalage une fois : place le LM35 à côté d'un thermomètre fiable et soustrais l'écart constant dans ton code.

LM35 avec l'ESP32 : alimentation 3,3 V et linéarité de l'ADC

L'ESP32 fonctionne en 3,3 V, mais la fiche technique du LM35 exige au moins 4 V d'alimentation. Un LM35 alimenté en 3,3 V peut sembler fonctionner à température ambiante, mais sa précision n'est pas garantie. La bonne méthode consiste à l'alimenter depuis la broche 5V de la carte (VIN sur certaines), c'est-à-dire avec le 5 V de l'USB. Cela n'abîme pas l'ESP32, car même au plus chaud (150 °C) la sortie du LM35 ne dépasse jamais 1,5 V. Relie toujours la sortie à une broche ADC1 (GPIO 32–39), car les broches ADC2 sont inutilisables quand le Wi-Fi est actif. Pour le brochage détaillé de ta carte, utilise l'outil Pinout, et si tu débutes avec l'ESP32, lis Qu'est-ce que l'ESP32.

Le second point est la linéarité de l'ADC de l'ESP32. Il travaille sur 12 bits (0–4095), mais n'est pas linéaire aux extrémités : il distingue à peine les tensions inférieures à 100 mV et son écart varie d'une carte à l'autre. Comme le LM35 ne fournit que 200 à 300 mV à température ambiante, cela te concerne directement. La solution tient en deux étapes : choisis l'atténuation en fonction de la plage de tension du LM35 et, au lieu de la valeur brute, utilise analogReadMilliVolts(), qui applique les données d'étalonnage écrites dans la puce en usine. Comme cette fonction renvoie directement des millivolts, il suffit de diviser le résultat par 10 pour obtenir la température.

1const int LM35_PIN = 34;     // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
2const int SAMPLES = 64;      // ortalama için ölçüm sayısı / number of samples to average
3
4void setup() {
5  Serial.begin(115200);
6  analogReadResolution(12);                       // 0–4095
7  analogSetPinAttenuation(LM35_PIN, ADC_2_5db);   // ~100–1250 mV, yani 10–125 °C / i.e. 10–125 °C
8}
9
10void loop() {
11  uint32_t sum = 0;
12  for (int i = 0; i < SAMPLES; i++) {
13    sum += analogReadMilliVolts(LM35_PIN);        // kalibre edilmiş mV / calibrated millivolts
14    delay(1);
15  }
16  float mv = sum / (float)SAMPLES;
17  float tempC = mv / 10.0;                        // 10 mV = 1 °C
18  Serial.printf("Gerilim / Voltage: %.1f mV  Sicaklik / Temp: %.2f C\n", mv, tempC);
19  delay(1000);
20}

LM35 avec le Raspberry Pi Pico et MicroPython

L'ADC 12 bits du Pico se trouve sur les broches GP26, GP27 et GP28 ; il utilise comme référence ADC_VREF, une version filtrée du rail 3,3 V. En MicroPython, read_u16() ramène le résultat sur 0–65535, donc tension = brut × 3,3 / 65535. La résolution théorique est de 0,8 mV, soit environ 0,08 °C, mais en pratique l'ADC du Pico est un peu bruité et fait de petits sauts sur certaines valeurs : la moyenne est donc indispensable ici aussi. Alimente le LM35 depuis VBUS (broche 40), qui transporte le 5 V de l'USB ; si tu alimentes le Pico sur piles plutôt qu'en USB, vérifie que la tension sur VSYS dépasse 4 V et alimente le capteur à partir de là. Si c'est ton premier Pico, l'installation de MicroPython est expliquée dans Qu'est-ce que le Raspberry Pi Pico.

1from machine import ADC, Pin
2import time
3
4# Pin(23, Pin.OUT, value=1)  # yalnız Pico (W değil): regülatör PWM modu, daha az gürültü / Pico (not W) only: SMPS PWM mode, less noise
5lm35 = ADC(26)               # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6VREF = 3.3                   # ADC_VREF'i multimetreyle ölçüp yaz / measure ADC_VREF with a multimeter
7SAMPLES = 64                 # ortalama için ölçüm sayısı / number of samples to average
8
9
10def read_temp_c():
11    total = 0
12    for _ in range(SAMPLES):
13        total += lm35.read_u16()   # 0–65535, 12 bit sonuç 16 bite ölçeklenir / 12-bit result scaled to 16 bits
14    raw = total / SAMPLES
15    volts = raw * VREF / 65535
16    return volts * 100             # 10 mV/°C
17
18
19while True:
20    t = read_temp_c()
21    print("Sicaklik / Temp: {:.2f} C".format(t))
22    time.sleep(1)

La puce du Pico possède aussi un capteur de température (ADC(4)), mais il mesure la température de la puce elle-même, pas celle de la pièce, et indique généralement quelques degrés de trop en fonctionnement ; pour la température ambiante, il faut un capteur externe comme le LM35. Pour des mesures plus propres sur un Pico standard, tu peux mettre GP23 à HIGH afin de passer le régulateur de la carte en mode PWM ; cela réduit l'ondulation sur ADC_VREF, au prix d'une consommation un peu plus élevée au repos. Sur le Pico W, cette broche est réservée à la puce sans fil, c'est pourquoi la ligne est laissée en commentaire dans le code.

Mesurer des températures négatives avec le LM35

Dans le montage de base, le LM35 ne mesure que de 2 °C à 150 °C, car son étage de sortie peut fournir du courant mais presque pas en absorber : la sortie ne peut donc pas descendre sous la masse. Pour les températures négatives, la fiche technique propose deux solutions. La première consiste à relier la sortie à une alimentation négative via une résistance (R = Vs / 50 µA, soit 100 kΩ pour −5 V), ce qui est rare dans les projets Arduino faute d'alimentation négative. La seconde fonctionne avec une seule alimentation : tu surélèves la patte GND du LM35 d'environ 1 V au-dessus de la masse avec deux diodes en série (par exemple des 1N4148), tu relies une résistance de 18 kΩ entre la sortie et la masse, puis tu lis la sortie sur A0 et la patte GND du LM35 sur A1. La température vaut alors (tension sur A0 − tension sur A1) × 100. Pour garder au moins 4 V entre les pattes du LM35, alimente +Vs depuis VIN (par exemple un bloc 9 V) plutôt que depuis le 5 V, et utilise la référence de 5 V. N'oublie pas que le LM35DZ courant n'est pas garanti sous 0 °C ; si tu mesures souvent des températures négatives, le DS18B20 est bien plus simple.

Comparatif LM35, DS18B20 et DHT11

En résumé : si tu veux un thermomètre simple, réactif, sans bibliothèque, lu sur une seule broche analogique et alimenté par un Arduino en 5 V, le LM35 est idéal ; c'est aussi le capteur le plus formateur pour apprendre la lecture analogique et les références de l'ADC. Si le câble est long, si tu dois mesurer sous zéro, si le capteur plonge dans un liquide ou si tu travailles avec des cartes en 3,3 V comme l'ESP32 et le Pico, le DS18B20 est le meilleur choix. Si tu veux aussi l'humidité, prends le DHT11 ou son grand frère plus précis, le DHT22. Pour un comparatif plus large incluant la thermistance CTN, le BME280 et d'autres, consulte Comparatif des capteurs de température pour Arduino.

Idées de projets avec le LM35

Le projet LM35 le plus courant est un thermostat qui allume un ventilateur quand la température dépasse un seuil. L'essentiel est d'utiliser une hystérésis : si le ventilateur s'allume à 30 °C et s'éteint à 28 °C, le relais ne claque pas toutes les secondes quand la température oscille autour du seuil, et ses contacts ne s'usent pas. Tu peux commander le ventilateur avec un module relais relié à D7 :

1const int LM35_PIN = A0;
2const int RELAY_PIN = 7;          // röle modülünün IN pini / relay module IN pin
3const float ON_TEMP = 30.0;       // bu değerde fan açılır / fan turns on here
4const float OFF_TEMP = 28.0;      // bu değerde fan kapanır / fan turns off here
5const float VREF = 1.1;           // ölçtüğün AREF değeri / your measured AREF value
6bool fanOn = false;
7
8float readTempC() {
9  long sum = 0;
10  for (int i = 0; i < 32; i++) {
11    sum += analogRead(LM35_PIN);
12  }
13  return (sum / 32.0) * VREF / 1024.0 * 100.0;
14}
15
16void setup() {
17  Serial.begin(9600);
18  pinMode(RELAY_PIN, OUTPUT);
19  digitalWrite(RELAY_PIN, LOW);
20  analogReference(INTERNAL);      // 1,1 V referans / 1.1 V reference
21  analogRead(LM35_PIN);           // ilk okumayı at / discard the first reading
22  delay(10);
23}
24
25void loop() {
26  float t = readTempC();
27  if (!fanOn && t >= ON_TEMP) fanOn = true;      // eşik aşıldı / threshold exceeded
28  if (fanOn && t <= OFF_TEMP) fanOn = false;     // yeterince soğudu / cooled down enough
29  digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW);   // aktif-HIGH röle varsayıldı / assumes an active-HIGH relay
30  Serial.print(t, 1);
31  Serial.println(fanOn ? " C  fan ON" : " C  fan OFF");
32  delay(1000);
33}

• Thermostat de ventilateur réglable : combine le code ci-dessus avec un ventilateur DC et un relais, et règle le seuil avec deux boutons poussoirs.
• Thermomètre numérique avec écran : affiche la température sur un écran LCD I2C ou un écran OLED avec le minimum et le maximum de la journée.
• Alarme de surchauffe : fais sonner un buzzer et allume une LED quand une alimentation, un chargeur de batterie ou le moteur d'une imprimante 3D chauffe trop.
• Thermomètre d'intérieur Wi-Fi : affiche la température mesurée par l'ESP32 sur une page web que tu ouvres sur ton téléphone.
• Pilotage de serre et de couveuse : construis un système qui gère un chauffage et un ventilateur selon la température ; tous les détails dans l'article sur la serre connectée.
• Enregistreur de température : écris une mesure par minute sur une carte SD et trace la courbe de la journée dans Excel.

Erreurs fréquentes et solutions

Le LM35 est un composant idéal pour débuter avec la lecture de capteurs analogiques, les références de l'ADC et le filtrage du signal : tu pars d'une seule formule, puis la bonne référence, la moyenne et l'étalonnage rendent ta mesure aussi fiable qu'un thermomètre. Tu appliqueras la même logique à d'autres capteurs analogiques comme la thermistance CTN. Dans l'application BlueGrays, tu trouveras des projets comme la mesure de température avec CTN et écran LCD, la température et l'humidité avec le DHT11, une station de température ESP32 avec écran LCD et un enregistreur de température, chacun avec schémas pas à pas et code prêt à l'emploi.