LM35 Arduino Temperatursensor: Anschluss, Formel und Code

Der LM35 ist ein günstiger analoger Temperatursensor mit drei Beinchen, der die Temperatur direkt in eine Spannung in Grad Celsius umwandelt. Für den LM35 am Arduino brauchst du weder eine Bibliothek noch ein kompliziertes Protokoll: Du verbindest das mittlere Bein mit einem Analogpin, liest es mit analogRead() aus und erhältst die Temperatur mit einer einzeiligen Formel. Sein Ausgang steigt pro 1 °C um genau 10 mV, liefert also 250 mV bei 25 °C und 1 V bei 100 °C.

In dieser Anleitung lernst du, wie der LM35 funktioniert, wie seine Pinbelegung aussieht und welchen Verpolungsfehler fast jeder einmal macht. Du rechnest den analogRead-Wert in °C um, machst deine Messung mit der internen 1,1-V-Referenz des Arduino Uno mehr als viermal feiner und beruhigst zappelnde Werte durch Mittelwertbildung. Danach siehst du, worauf du beim ESP32 und beim Raspberry Pi Pico mit 3,3 V achten musst, wie man Minusgrade misst und wann der LM35 die bessere Wahl gegenüber DS18B20 und DHT11 ist.

Was ist der LM35 und wie funktioniert er?

Im LM35 arbeiten zwei Transistoren mit unterschiedlicher Stromdichte. Die Differenz ihrer Basis-Emitter-Spannungen ändert sich direkt proportional zur absoluten Temperatur; dieses Verfahren heißt Delta-VBE. Ein interner Verstärker hebt diese winzige Differenz an und skaliert sie so, dass der Ausgang bei 0 °C genau 0 V liefert. Anders als bei Kelvin-Sensoren wie dem LM335 musst du deshalb keine große konstante Spannung abziehen: Temperatur (°C) = Ausgangsspannung (mV) / 10. Der Sensor wird schon bei der Fertigung auf Wafer-Ebene abgeglichen, braucht also keine weitere Kalibrierung, und seine Kennlinie ist fast schnurgerade; die typische Nichtlinearität beträgt nur ±0,25 °C.

Der LM35 ist kein einzelnes Bauteil, sondern eine Familie. Der Buchstabe im Namen bestimmt Messbereich und garantierte Genauigkeit, ein angehängtes Z steht für das Kunststoffgehäuse TO-92. Laut Datenblatt gibt es im TO-92-Gehäuse den LM35C, LM35CA und LM35D; die meisten Teile, die im Bastelhandel als "LM35" verkauft werden, sind in Wirklichkeit LM35DZ. Dein Sensor ist also sehr wahrscheinlich nur für 0–100 °C spezifiziert und darf bei 25 °C bis zu ±1,5 °C danebenliegen; typisch sind etwa ±0,6 °C. Die Aufschrift auf dem Bauteil verrät dir, welche Variante du hast.

LM35 Pinbelegung und der häufigste Verpolungsfehler

Wenn die flache Seite des LM35 zu dir zeigt und die Beinchen nach unten, ist die Reihenfolge von links nach rechts: Pin 1 +Vs (Versorgung), Pin 2 Vout (Ausgang) und Pin 3 GND (Masse). Weil die Zeichnung im Datenblatt eine Ansicht von unten ist, drehen viele sie im Kopf falsch herum und verdrahten den Sensor verkehrt. Bei LM35-Modulen auf einer kleinen Platine sind die Pins meist mit VCC (oder +), OUT (oder S) und GND (oder −) beschriftet; dann verlass dich auf die Beschriftung.

LM35 am Arduino anschließen: Uno, ESP32 und Pico

Vom analogRead-Wert zu °C: die LM35-Formel

Der Analog-Digital-Wandler (ADC) des Arduino Uno hat 10 Bit: Er teilt den Bereich zwischen 0 V und der Referenzspannung in 1024 Stufen und liefert dir eine Zahl von 0 bis 1023. Da die Referenz standardmäßig 5 V beträgt, entspricht jede Stufe 5 / 1024 = 4,88 mV. Zuerst rechnest du den Rohwert in eine Spannung um, dann die Spannung in eine Temperatur: Spannung = Rohwert × 5,0 / 1024 und Temperatur = Spannung × 100. Zusammengefasst gilt Temperatur ≈ Rohwert × 0,488. In manchen Beispielen steht 1023 statt 1024; der Unterschied beträgt ein Promille und ist neben dem Eigenfehler des LM35 bedeutungslos, korrekt ist aber 1024. Wenn du den ADC genauer verstehen willst, lies den Artikel zur Analog-Digital-Wandlung (ADC).

Schau dir die Tabelle genau an: Bei Zimmertemperatur liefert der ADC nur eine Zahl um 50, und eine einzige Stufe verschiebt die Temperatur um etwa 0,5 °C. Deshalb springt dein Wert zwischen 24,9 und 25,4 hin und her; der Sensor ist nicht defekt, das ist schlicht die Auflösung der 5-V-Referenz. Gleich beheben wir das mit der internen Referenz.

Die erste Messung Schritt für Schritt

1. Steck den LM35 ins Steckbrett; mit der flachen Seite zu dir verbindest du das linke Bein mit 5V und das rechte mit GND.
2. Verbinde das mittlere Bein (Vout) mit einem Jumperkabel mit A0. Falls vorhanden, setz einen 0,1-µF-Kondensator zwischen +Vs und GND.
3. Schließ den Arduino per USB an und fass den Sensor nach ein paar Sekunden an: Fühlt er sich zimmerwarm an, ist alles in Ordnung; ist er heiß, ist er verpolt.
4. Lade den folgenden Code hoch und öffne den seriellen Monitor mit 9600 Baud.
5. Nimm den Sensor zwischen die Finger; der Wert sollte langsam steigen und beim Loslassen wieder sinken.

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}

Der Code liest jede Sekunde den Rohwert an A0, rechnet ihn zuerst in eine Spannung und dann in eine Temperatur um und gibt alle drei im seriellen Monitor aus. Den Rohwert mit auszugeben hilft enorm bei der Fehlersuche: Ist er dauerhaft 0, kommt keine Spannung von Vout; liegt er nahe 1023, hängt der Analogpin versehentlich an 5 V; springt er zufällig, ist A0 offen. Feste Texte im Makro F() sparen den knappen 2 KB RAM des Uno. Weitere Tipps zum seriellen Monitor findest du im Artikel Arduino Serial Monitor richtig nutzen.

Mehr Auflösung mit der internen 1,1-V-Referenz

Die 5-V-Referenz hat zwei Probleme. Das erste ist die grobe Auflösung, die du gerade gesehen hast. Das zweite ist tückischer: Die 5 V vom USB liegen oft irgendwo zwischen 4,7 und 5,1 V, und weil im Code 5,0 steht, landet die Abweichung direkt in der Temperatur. Läuft deine Platine zum Beispiel tatsächlich mit 4,8 V, siehst du 25 °C als 26 °C, und wenn der USB-Port deines Rechners unter Last einbricht, scheint sich die Temperatur von selbst zu ändern. Die Lösung ist die interne 1,1-V-Referenz des ATmega328P im Arduino Uno und Nano. Nach analogReference(INTERNAL) entspricht jede Stufe 1,1 / 1024 = 1,07 mV, also etwa 0,11 °C. Dafür kannst du höchstens 1,1 V messen, also 110 °C; für den Bereich 0–100 °C des LM35DZ reicht das ohnehin.

Die 1,1-V-Referenz liegt nicht bei jedem Chip genau bei 1,1 V; laut Datenblatt des ATmega328P kann sie zwischen 1,0 und 1,2 V betragen. Ohne Kalibrierung bedeutet das einen Skalierungsfehler von bis zu 9 %. Die Abhilfe ist einfach: Lade den folgenden Code hoch, miss mit dem Multimeter die Spannung zwischen dem AREF-Pin und GND und trag den Wert in die Konstante VREF ein (z. B. const float VREF = 1.083;). Das machst du einmal pro Platine, das Ergebnis bleibt gültig. Außerdem mittelt der Code bei jeder Messung 32 Einzelwerte:

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}

Mittelwertbildung und weniger Rauschen

Ein einzelnes analogRead kann wegen Störungen auf den Leitungen und Welligkeit der Versorgung um ein bis zwei Stufen schwanken. Die einfachste und wirksamste Abhilfe ist, mehrere Messungen zu mitteln: Zufälliges Rauschen sinkt mit der Wurzel aus der Anzahl der Werte, der Mittelwert aus 16 Messungen drückt es also auf ein Viertel, aus 64 Messungen auf ein Achtel. Weil sich Temperatur langsam ändert, kosten dich Dutzende Messungen innerhalb weniger Millisekunden keine Zeit. Für eine noch glattere Kurve nimmst du einen exponentiellen Filter: gefiltert = gefiltert + 0,1 × (neu − gefiltert). Er berücksichtigt nur 10 Prozent jedes neuen Werts und braucht nur eine Variable im Speicher. Weitere Verfahren wie gleitenden Mittelwert und Median vergleichen wir im Artikel Sensordaten filtern.

• Nach einem Kanalwechsel den ersten Wert verwerfen: Liest du mehrere Analogsensoren, hält der Abtastkondensator des ADC kurz die Spannung des vorherigen Kanals; lies den Pin zweimal und ignoriere das erste Ergebnis.
• GND des Sensors direkt zum GND-Pin des Arduino führen: Fließt der Strom eines Relais, Motors oder LED-Streifens über dieselbe Masseleitung, entstehen Verschiebungen im Millivoltbereich, und beim LM35 sind 10 mV ein ganzes Grad.
• Kabel kurz halten und fern von Stromleitungen verlegen: Lange, ungeschirmte Leitungen wirken wie Antennen; nutze bei Bedarf verdrillte oder geschirmte Kabel.
• Sensor von Wärmequellen fernhalten: Ein LM35 direkt neben einem Spannungsregler, einem ESP32-Modul oder einem Relais misst die Platinentemperatur, nicht die Raumtemperatur.
• Einmal den Offset kalibrieren: Leg den LM35 neben ein zuverlässiges Thermometer und zieh die konstante Differenz im Code ab.

LM35 am ESP32: 3,3-V-Versorgung und ADC-Linearität

Der ESP32 arbeitet mit 3,3 V, doch laut Datenblatt braucht der LM35 mindestens 4 V Versorgung. Ein LM35 an 3,3 V scheint bei Zimmertemperatur vielleicht zu funktionieren, seine Genauigkeit ist aber nicht garantiert. Richtig ist, den Sensor aus dem 5V-Pin der Platine (bei manchen Boards VIN) zu speisen, also mit den 5 V vom USB. Das schadet dem ESP32 nicht, denn selbst im heißesten Fall (150 °C) übersteigt der Ausgang des LM35 nie 1,5 V. Schließ den Ausgang unbedingt an einen ADC1-Pin (GPIO 32–39) an, denn die ADC2-Pins sind bei aktivem WLAN nicht nutzbar. Die genaue Pinbelegung deines Boards zeigt dir das Pinout-Werkzeug, und als ESP32-Einsteiger hilft dir der Artikel Was ist der ESP32.

Das zweite Thema ist die Linearität des ESP32-ADC. Er hat 12 Bit (0–4095), ist an den Rändern aber nicht linear: Spannungen unter 100 mV kann er kaum unterscheiden, und die Abweichung ist von Board zu Board verschieden. Da der LM35 bei Zimmertemperatur nur 200–300 mV liefert, betrifft dich das direkt. Die Lösung hat zwei Schritte: Wähle die Dämpfung (Attenuation) passend zum Spannungsbereich des LM35, und nutze statt des Rohwerts analogReadMilliVolts(), das die bei der Fertigung im Chip gespeicherten Kalibrierdaten anwendet. Da die Funktion direkt Millivolt liefert, teilst du das Ergebnis nur noch durch 10.

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 mit Raspberry Pi Pico und MicroPython

Der 12-Bit-ADC des Pico liegt an den Pins GP26, GP27 und GP28; als Referenz nutzt er ADC_VREF, eine gefilterte Version der 3,3-V-Schiene. In MicroPython skaliert read_u16() das Ergebnis auf 0–65535, also gilt Spannung = Rohwert × 3,3 / 65535. Die theoretische Auflösung beträgt 0,8 mV, also etwa 0,08 °C, in der Praxis rauscht der ADC des Pico aber etwas und springt bei bestimmten Werten leicht, deshalb ist auch hier Mittelwertbildung Pflicht. Versorge den LM35 über VBUS (Pin 40), der die 5 V vom USB führt; betreibst du den Pico mit Batterien statt über USB, stell sicher, dass an VSYS mehr als 4 V anliegen, und speise den Sensor von dort. Nutzt du den Pico zum ersten Mal, findest du die MicroPython-Installation im Artikel Was ist der 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)

Auch im Chip des Pico steckt ein Temperatursensor (ADC(4)), er misst aber die Temperatur des Chips selbst, nicht die des Raums, und zeigt im Betrieb meist ein paar Grad zu viel; für die Raumtemperatur brauchst du einen externen Sensor wie den LM35. Für sauberere Werte kannst du beim normalen Pico GP23 auf HIGH setzen und so den Spannungsregler der Platine in den PWM-Modus schalten; das verringert die Welligkeit an ADC_VREF, kostet im Leerlauf aber etwas mehr Strom. Beim Pico W ist dieser Pin für den Funkchip reserviert, deshalb ist die Zeile im Code auskommentiert.

Minusgrade mit dem LM35 messen

In der Grundschaltung misst der LM35 nur von 2 °C bis 150 °C, weil seine Ausgangsstufe zwar Strom liefern, aber kaum Strom aufnehmen kann; der Ausgang kommt also nicht unter Masse. Für Minusgrade zeigt das Datenblatt zwei Wege. Der erste ist, den Ausgang über einen Widerstand an eine negative Spannung zu legen (R = Vs / 50 µA; 100 kΩ bei −5 V), was in Arduino-Projekten mangels negativer Versorgung selten vorkommt. Der zweite ist die Methode mit einfacher Versorgung: Du hebst den GND-Pin des LM35 mit zwei Dioden in Reihe (z. B. 1N4148) etwa 1 V über Masse, schaltest einen 18-kΩ-Widerstand zwischen Ausgang und Masse und liest den Ausgang an A0 und den GND-Pin des LM35 an A1. Die Temperatur ist dann (Spannung an A0 − Spannung an A1) × 100. Damit zwischen den Pins des LM35 mindestens 4 V bleiben, versorgst du +Vs hier aus VIN (z. B. 9-V-Netzteil) statt aus 5 V und nutzt die 5-V-Referenz. Denk daran: Der verbreitete LM35DZ ist unter 0 °C nicht spezifiziert; brauchst du oft Minusgrade, ist der DS18B20 viel bequemer.

LM35, DS18B20 und DHT11 im Vergleich

Kurz gesagt: Willst du ein einfaches Thermometer, das schnell reagiert, keine Bibliothek braucht, mit einem einzigen Analogpin auskommt und an einem 5-V-Arduino läuft, ist der LM35 ideal; außerdem ist er der lehrreichste Sensor, um analoges Messen und ADC-Referenzen zu verstehen. Ist das Kabel lang, brauchst du Minusgrade, soll der Sensor in eine Flüssigkeit oder arbeitest du mit 3,3-V-Boards wie ESP32 und Pico, ist der DS18B20 die bessere Wahl. Willst du auch die Luftfeuchte, nimm den DHT11 oder seinen genaueren Bruder DHT22. Einen breiteren Vergleich mit NTC-Thermistor, BME280 und weiteren findest du unter Arduino-Temperatursensoren im Vergleich.

Projektideen mit dem LM35

Das beliebteste LM35-Projekt ist ein Thermostat, der einen Lüfter einschaltet, sobald die Temperatur einen Grenzwert überschreitet. Entscheidend ist eine Hysterese: Schaltet der Lüfter bei 30 °C ein und bei 28 °C aus, klackt das Relais nicht im Sekundentakt, wenn die Temperatur genau um die Schwelle pendelt, und seine Kontakte verschleißen nicht. Den Lüfter steuerst du über ein Relaismodul an 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}

• Einstellbarer Lüfterthermostat: Kombiniere den Code oben mit einem DC-Lüfter und einem Relais und verstelle die Schwelle mit zwei Tastern.
• Digitalthermometer mit LCD: Zeig die Temperatur samt Tagesminimum und -maximum auf einem I2C-LCD oder einem OLED-Display.
• Überhitzungsalarm: Lass einen Summer ertönen und eine LED leuchten, wenn ein Netzteil, ein Akkuladegerät oder ein 3D-Drucker-Motor zu heiß wird.
• WLAN-Raumthermometer: Zeig die vom ESP32 gemessene Temperatur auf einer Webseite, die du am Handy öffnest.
• Gewächshaus- und Brutkastensteuerung: Bau ein System, das Heizung und Lüfter nach der Temperatur regelt; Details im Artikel zum smarten Gewächshaus.
• Temperaturlogger: Schreib jede Minute einen Messwert auf eine SD-Karte und zeichne die Tageskurve in Excel.

Häufige Fehler und Lösungen

Der LM35 ist das perfekte Einsteigerbauteil, um analoges Messen, ADC-Referenzen und Signalfilterung zu lernen: Du startest mit einer einzigen Formel und machst deine Messung dann mit der richtigen Referenz, Mittelwertbildung und Kalibrierung so verlässlich wie ein Thermometer. Dieselbe Vorgehensweise brauchst du auch bei anderen analogen Sensoren wie dem NTC-Thermistor. In der BlueGrays-App findest du Projekte wie Temperaturmessung mit NTC und LCD, Temperatur und Luftfeuchte mit dem DHT11, eine ESP32-Temperaturstation mit LCD und einen Temperaturlogger, jeweils mit Schaltplänen Schritt für Schritt und fertigem Code.