LM35 Arduino: sensore di temperatura, collegamento e codice

L'LM35 è un sensore di temperatura analogico economico a tre piedini che converte la temperatura direttamente in una tensione in gradi Celsius. Per usare l'LM35 con Arduino non servono librerie né protocolli complicati: colleghi il piedino centrale a un pin analogico, lo leggi con analogRead() e ottieni la temperatura con una formula di una riga. La sua uscita sale esattamente di 10 mV per ogni grado, quindi dà 250 mV a 25 °C e 1 V a 100 °C.

In questa guida imparerai come funziona l'LM35, l'ordine dei suoi piedini e l'errore di collegamento invertito che quasi tutti commettono almeno una volta, come calcolare i °C dal valore di analogRead, come rendere le letture più di quattro volte più fini con il riferimento interno da 1,1 V dell'Arduino Uno e come calmare i valori ballerini facendo la media. Poi vedrai a cosa fare attenzione con ESP32 e Raspberry Pi Pico a 3,3 V, come si misurano le temperature sotto zero e quando scegliere l'LM35 invece del DS18B20 o del DHT11.

Che cos'è l'LM35 e come funziona?

All'interno dell'LM35 ci sono due transistor che lavorano con densità di corrente diverse. La differenza tra le loro tensioni base-emettitore varia in modo direttamente proporzionale alla temperatura assoluta; questa tecnica si chiama delta-VBE. Un amplificatore interno amplifica questa piccola differenza e la scala in modo che l'uscita valga 0 V a 0 °C. Per questo, a differenza dei sensori in kelvin come l'LM335, non devi sottrarre una grande tensione costante: temperatura (°C) = tensione di uscita (mV) / 10. Il sensore viene tarato direttamente sul wafer in fabbrica, quindi non richiede calibrazioni aggiuntive e la sua curva è quasi perfettamente lineare; la non linearità tipica è di appena ±0,25 °C.

L'LM35 non è un singolo componente ma una famiglia. La lettera del suffisso stabilisce il campo di misura e la precisione garantita, mentre la Z finale indica il package plastico TO-92. Secondo il datasheet, in TO-92 plastico esistono LM35C, LM35CA e LM35D; la maggior parte dei pezzi venduti come "LM35" nei negozi di elettronica sono in realtà LM35DZ. Quindi il tuo sensore è molto probabilmente garantito solo tra 0 e 100 °C e può sbagliare fino a ±1,5 °C a 25 °C, anche se l'errore tipico è di circa ±0,6 °C. Leggi la sigla stampata sul componente per sapere quale hai.

Piedinatura dell'LM35 e l'errore più comune: il collegamento invertito

Con la faccia piatta dell'LM35 rivolta verso di te e i piedini verso il basso, l'ordine da sinistra a destra è: piedino 1 +Vs (alimentazione), piedino 2 Vout (uscita) e piedino 3 GND (massa). Dato che il disegno del datasheet è una vista dal basso, molti lo ribaltano mentalmente e lo collegano al contrario. Sui moduli LM35 montati su una piccola scheda i pin sono di solito marcati VCC (o +), OUT (o S) e GND (o −); in quel caso fidati della serigrafia.

Collegamento dell'LM35 ad Arduino: Uno, ESP32 e Pico

Dal valore di analogRead ai °C: la formula dell'LM35

Il convertitore analogico-digitale (ADC) dell'Arduino Uno è a 10 bit: divide l'intervallo tra 0 V e la tensione di riferimento in 1024 gradini e ti restituisce un numero da 0 a 1023. Poiché il riferimento predefinito è 5 V, ogni gradino vale 5 / 1024 = 4,88 mV. Prima converti il valore grezzo in tensione, poi la tensione in temperatura: tensione = grezzo × 5,0 / 1024 e temperatura = tensione × 100. Mettendole insieme, temperatura ≈ grezzo × 0,488. In alcuni esempi troverai 1023 al posto di 1024; la differenza è di un millesimo e trascurabile rispetto all'errore dell'LM35, ma il valore corretto è 1024. Se vuoi capire meglio l'ADC, leggi l'articolo sulla conversione analogico-digitale (ADC).

Guarda bene la tabella: a temperatura ambiente l'ADC produce solo un numero intorno a 50 e un singolo gradino sposta la temperatura di circa 0,5 °C. Ecco perché la lettura salta tra 24,9 e 25,4; il sensore non è guasto, è semplicemente la risoluzione del riferimento a 5 V. Tra poco lo sistemeremo con il riferimento interno.

Prima misura passo dopo passo

1. Inserisci l'LM35 nella breadboard; con la faccia piatta verso di te, collega il piedino sinistro a 5V e quello destro a GND.
2. Collega il piedino centrale (Vout) ad A0 con un cavetto jumper. Se ce l'hai, aggiungi un condensatore da 0,1 µF tra +Vs e GND.
3. Collega Arduino via USB e tocca il sensore dopo qualche secondo: se è a temperatura ambiente va tutto bene, se scotta è collegato al contrario.
4. Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
5. Stringi il sensore tra le dita; dovresti vedere il valore salire lentamente e poi scendere quando lo lasci.

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}

Ogni secondo il codice legge il valore grezzo su A0, lo converte prima in tensione e poi in temperatura e stampa tutti e tre sul Monitor seriale. Stampare anche il valore grezzo aiuta molto nel debug: se è sempre 0, da Vout non arriva tensione; se è vicino a 1023, il pin analogico è collegato per errore a 5 V; se salta a caso, A0 è scollegato. Scrivere i testi fissi dentro la macro F() fa risparmiare i 2 KB di RAM dell'Uno. Trovi altri consigli nell'articolo su come usare il Monitor seriale di Arduino.

Più risoluzione con il riferimento interno da 1,1 V

Il riferimento a 5 V ha due problemi. Il primo è la risoluzione grossolana che hai appena visto. Il secondo è più subdolo: i 5 V dell'USB stanno spesso tra 4,7 e 5,1 V e, poiché nel codice scrivi 5,0, la differenza finisce direttamente nella temperatura. Per esempio, se la scheda in realtà funziona a 4,8 V, leggerai 26 °C invece di 25 °C, e quando la porta USB del computer cala sotto carico sembra che la temperatura cambi da sola. La soluzione è usare il riferimento interno da 1,1 V dell'ATmega328P di Arduino Uno e Nano. Dopo analogReference(INTERNAL) ogni gradino vale 1,1 / 1024 = 1,07 mV, cioè circa 0,11 °C. In cambio puoi misurare al massimo 1,1 V, cioè 110 °C, più che sufficienti per il campo 0–100 °C dell'LM35DZ.

Il riferimento da 1,1 V non vale esattamente 1,1 V su ogni chip; secondo il datasheet dell'ATmega328P può essere compreso tra 1,0 e 1,2 V. Senza taratura questo significa un errore di scala fino al 9%. Il rimedio è semplice: carica il codice qui sotto, misura con il multimetro la tensione tra il pin AREF e GND e scrivi il valore nella costante VREF (per esempio const float VREF = 1.083;). Basta farlo una volta per scheda e il risultato resta valido. Il codice inoltre fa la media di 32 campioni a ogni lettura:

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}

Fare la media e ridurre il rumore

Una singola lettura di analogRead può oscillare di uno o due gradini per i disturbi sui cavi e il ripple dell'alimentazione. La soluzione più semplice ed efficace è fare la media di più letture: il rumore casuale diminuisce con la radice quadrata del numero di campioni, quindi la media di 16 letture lo riduce a un quarto e quella di 64 a un ottavo. Dato che la temperatura cambia lentamente, decine di letture in pochi millisecondi non ti fanno perdere tempo. Per una curva ancora più morbida usa un filtro esponenziale: filtrato = filtrato + 0,1 × (nuovo − filtrato). Questo filtro considera solo il 10% di ogni nuova lettura e tiene in memoria una sola variabile. Confrontiamo altri metodi, come la media mobile e la mediana, nell'articolo su come filtrare i dati dei sensori.

• Scarta la prima lettura dopo aver cambiato canale: se leggi più sensori analogici, il condensatore di campionamento dell'ADC conserva per un attimo la tensione del canale precedente; leggi lo stesso pin due volte e ignora il primo risultato.
• Porta il GND del sensore direttamente al pin GND di Arduino: se la corrente di un relè, di un motore o di una striscia LED passa per lo stesso filo di massa, compaiono spostamenti di qualche millivolt, e nell'LM35 ogni 10 mV vale un grado.
• Tieni il cavo corto e lontano dai cavi di potenza: i cavi lunghi non schermati si comportano come antenne; se serve usa cavo intrecciato o schermato.
• Allontana il sensore dalle fonti di calore: un LM35 accanto a un regolatore di tensione, a un modulo ESP32 o a un relè misura la temperatura della scheda, non quella della stanza.
• Calibra l'offset una volta: lascia l'LM35 accanto a un termometro affidabile e sottrai nel codice la differenza costante.

LM35 con ESP32: alimentazione a 3,3 V e linearità dell'ADC

L'ESP32 lavora a 3,3 V, ma il datasheet dell'LM35 richiede almeno 4 V di alimentazione. Un LM35 alimentato a 3,3 V può sembrare funzionante a temperatura ambiente, ma la sua precisione non è garantita. La strada giusta è alimentare il sensore dal pin 5V della scheda (VIN su alcune), cioè con i 5 V dell'USB. Questo non danneggia l'ESP32, perché anche nel caso più caldo (150 °C) l'uscita dell'LM35 non supera mai 1,5 V. Collega sempre l'uscita a un pin ADC1 (GPIO 32–39), perché i pin ADC2 non sono utilizzabili con il Wi-Fi attivo. Per la piedinatura dettagliata della tua scheda usa lo strumento Pinout e, se sei alle prime armi con l'ESP32, leggi Che cos'è l'ESP32.

Il secondo tema è la linearità dell'ADC dell'ESP32. È a 12 bit (0–4095), ma non è lineare agli estremi: distingue a fatica le tensioni sotto i 100 mV e il suo scostamento cambia da scheda a scheda. Poiché l'LM35 a temperatura ambiente fornisce solo 200–300 mV, la cosa ti riguarda direttamente. La soluzione ha due passi: scegli l'attenuazione in base al campo di tensione dell'LM35 e, al posto del valore grezzo, usa analogReadMilliVolts(), che applica i dati di taratura scritti nel chip in fabbrica. Dato che la funzione restituisce direttamente millivolt, ti basta dividere il risultato per 10 per avere la temperatura.

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 con Raspberry Pi Pico e MicroPython

L'ADC a 12 bit del Pico si trova sui pin GP26, GP27 e GP28; come riferimento usa ADC_VREF, una versione filtrata della linea a 3,3 V. In MicroPython read_u16() scala il risultato su 0–65535, quindi tensione = grezzo × 3,3 / 65535. La risoluzione teorica è di 0,8 mV, circa 0,08 °C, ma in pratica l'ADC del Pico è un po' rumoroso e fa piccoli salti su certi valori, quindi anche qui la media è d'obbligo. Alimenta l'LM35 da VBUS (pin 40), che porta i 5 V dell'USB; se alimenti il Pico a batterie invece che via USB, assicurati che la tensione su VSYS superi i 4 V e alimenta il sensore da lì. Se usi il Pico per la prima volta, trovi l'installazione di MicroPython in Che cos'è il 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)

Anche il chip del Pico ha un sensore di temperatura (ADC(4)), ma misura la temperatura del chip stesso, non quella dell'ambiente, e durante il funzionamento di solito segna qualche grado in più; per la temperatura ambiente serve un sensore esterno come l'LM35. Per letture più pulite su un Pico standard puoi portare GP23 a HIGH e mettere in modalità PWM il regolatore della scheda; questo riduce il ripple su ADC_VREF, ma a riposo consuma un po' di più. Sul Pico W questo pin è riservato al chip wireless, per questo nel codice la riga è lasciata commentata.

Misurare temperature sotto zero con l'LM35

Nel montaggio di base l'LM35 misura solo da 2 °C a 150 °C, perché il suo stadio di uscita può erogare corrente ma quasi non può assorbirla, quindi l'uscita non può scendere sotto massa. Per le temperature negative il datasheet indica due strade. La prima è collegare l'uscita a un'alimentazione negativa tramite una resistenza (R = Vs / 50 µA; 100 kΩ per −5 V), cosa rara nei progetti Arduino perché manca l'alimentazione negativa. La seconda è il metodo ad alimentazione singola: sollevi il piedino GND dell'LM35 di circa 1 V sopra massa con due diodi in serie (per esempio 1N4148), colleghi una resistenza da 18 kΩ tra uscita e massa e leggi l'uscita su A0 e il piedino GND dell'LM35 su A1. La temperatura è (tensione su A0 − tensione su A1) × 100. Per mantenere almeno 4 V tra i piedini dell'LM35, in questo circuito alimenta +Vs da VIN (per esempio con un alimentatore da 9 V) invece che dai 5 V e usa il riferimento a 5 V. Ricorda che il diffuso LM35DZ non è garantito sotto 0 °C; se devi misurare spesso sotto zero, il DS18B20 è molto più comodo.

Confronto tra LM35, DS18B20 e DHT11

In breve: se vuoi un termometro semplice, reattivo, senza librerie, letto con un solo pin analogico e alimentato da un Arduino a 5 V, l'LM35 è ideale; è anche il sensore più istruttivo per imparare le letture analogiche e i riferimenti dell'ADC. Se il cavo è lungo, se devi misurare sotto zero, se il sensore va immerso in un liquido o se lavori con schede a 3,3 V come ESP32 e Pico, il DS18B20 è la scelta migliore. Se vuoi anche l'umidità, usa il DHT11 o il fratello più preciso DHT22. Per un confronto più ampio che include termistori NTC, BME280 e altri, leggi Confronto tra i sensori di temperatura per Arduino.

Idee di progetti con l'LM35

Il progetto più diffuso con l'LM35 è un termostato che accende una ventola quando la temperatura supera una soglia. La cosa importante è usare l'isteresi: se la ventola si accende a 30 °C e si spegne a 28 °C, il relè non scatta ogni secondo quando la temperatura oscilla proprio sulla soglia e i suoi contatti non si consumano. Puoi pilotare la ventola con un modulo relè collegato a 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}

• Termostato per ventola regolabile: unisci il codice qui sopra a una ventola DC e a un relè, e alza o abbassa la soglia con due pulsanti.
• Termometro digitale con display: mostra la temperatura su un display LCD I2C o su un display OLED insieme alla minima e alla massima del giorno.
• Allarme di surriscaldamento: fai suonare un buzzer e accendere un LED quando un alimentatore, un caricabatterie o il motore di una stampante 3D si scaldano troppo.
• Termometro Wi-Fi da stanza: mostra la temperatura misurata dall'ESP32 su una pagina web che apri dal telefono.
• Controllo di serra e incubatrice: realizza un sistema che gestisce riscaldatore e ventola in base alla temperatura; i dettagli sono nell'articolo sulla serra intelligente.
• Registratore di temperatura: salva una lettura al minuto su una scheda SD e traccia la curva giornaliera in Excel.

Errori comuni e soluzioni

L'LM35 è il componente perfetto per iniziare a imparare le letture analogiche, i riferimenti dell'ADC e il filtraggio dei segnali: parti da una sola formula e poi, con il riferimento giusto, la media e la taratura, rendi la misura affidabile quanto un termometro. Userai la stessa logica con altri sensori analogici come il termistore NTC. Nell'app BlueGrays trovi progetti come la misura della temperatura con NTC e LCD, temperatura e umidità con il DHT11, una stazione di temperatura ESP32 con LCD e un registratore di temperatura, ciascuno con schemi passo passo e codice pronto all'uso.