Measure temperature with the LM35

FunduinoLast updated on 11.10.2016

Temperaturen bis 150 °C messen – auch in Flüssigkeiten

Der LM35 ist einer der einfachsten Temperatursensoren überhaupt: Er braucht keine Bibliothek und keinen Bus, sondern gibt die Temperatur direkt als Spannung aus – genau 10 Millivolt je Grad Celsius. Du liest diese Spannung an einem analogen Eingang ein und rechnest sie um.

In dieser Anleitung lernst du beide Rechenwege kennen: den schnellen mit dem map-Befehl und den genaueren, der die Nachkommastellen behält. Zwischendurch baust du ein Warnsignal ein, das ab 30 °C ertönt.

Arduino mit Schraubklemmenshield und wasserdichtem LM35-Fühler in einem Glas Wasser — Temperaturmessung in Wasser mit dem wasserdichten LM35 und einem Schraubklemmenshield

LM35-Temperatursensor mit rotem Gehäuse und dreipoliger Buchse — Die Variante des LM35 mit XH2.54-3P-Buchse

1 / 2

Material

Für dieses Projekt brauchst du:

1× Mikrocontroller mit passendem USB-Kabel
1× Temperatursensor LM35 – wahlweise die wasserdichte Ausführung mit Kabel oder die Variante mit XH2.54-3P-Buchse
1× Schraubklemmenshield für den Arduino UNO (nur für die wasserdichte Ausführung)
3× Steckkabel männlich/männlich (nur für die Variante mit Buchse)

Für die Erweiterung mit Warnsignal kommt dazu:

1× Piezo-Summer

Wie der LM35 misst

Der LM35 hat drei Anschlüsse: Rot gehört an 5V, Schwarz an GND, und Gelb ist die Signalleitung. An dieser Leitung gibt der Sensor eine Spannung aus, die direkt der Temperatur entspricht – je Grad Celsius genau 10 Millivolt.

Der messbare Bereich reicht von 0 °C bis 150 °C, die Ausgangsspannung also von 0 V bis 1,5 V. Diese Spannung liest der Mikrocontroller an einem analogen Eingang ein und rechnet sie in einen Temperaturwert um. Die Messgenauigkeit liegt bei etwa ±1,5 °C.

Die wasserdichte Ausführung steckt in einer Metallhülse mit Kabel. Damit lässt sich auch die Temperatur von Flüssigkeiten messen.

Typische Einsatzgebiete solcher Sensoren:

Klimaanlagen in Autos und Wohnungen
Haushaltsgeräte: Spül- und Waschmaschinen halten ihre Temperatur, Wasserkocher schalten beim Erreichen der Zieltemperatur ab
Heizungssteuerung: Abschalten, sobald die gewünschte Temperatur erreicht ist
Überhitzungsschutz, zum Beispiel in Smartphones

Wird der Sensor falsch herum angeschlossen, kann er dauerhaft beschädigt werden. Prüfe die Farbzuordnung vor dem Einschalten.

Für genauere Messungen lohnt sich eine externe Stromversorgung über die Hohlbuchse (9-V-Netzteil oder 9-V-Block) statt der Versorgung über USB.

Nahaufnahme der dreipoligen Buchse mit rotem, schwarzem und gelbem Kontakt — Die drei Anschlüsse des LM35

1 / 2

Aufbau

Unabhängig von der Ausführung gilt immer dieselbe Zuordnung:

Rot → 5V
Schwarz → GND
Gelb → A0

Beim wasserdichten LM35 mit offenen Kabelenden klemmst du die drei Adern am besten in ein Schraubklemmenshield, das du auf den Arduino aufsteckst. Bei der Variante mit XH2.54-Buchse verbindest du die Buchse über drei männlich/männliche Leitungen direkt mit dem Board.

Arduino mit angeschlossenem LM35-Sensor — Anschluss am Arduino: Gelb an A0, Rot an 5V, Schwarz an GND

1 / 2

Der map-Befehl

Am analogen Eingang liefert der Arduino keinen Spannungswert, sondern eine Zahl zwischen 0 und 1023 für den Bereich 0 bis 5 Volt. Die 1,5 Volt des LM35 entsprechen darin einer Zahl von ungefähr 307.

Aus dieser Zahl macht der map-Befehl wieder eine Temperatur. Die allgemeine Schreibweise lautet map(a, b, c, d, e):

a = die umzuwandelnde Zahl
b = das Minimum des Messbereichs
c = das Maximum des Messbereichs
d = das Minimum des Ausgabebereichs
e = das Maximum des Ausgabebereichs

In unserem Fall wird also aus dem Bereich 0 bis 307 der Bereich 0 bis 150 Grad Celsius. Öffne nach dem Hochladen den Seriellen Monitor mit 9600 Baud.

map() rechnet mit ganzen Zahlen. Die angezeigte Temperatur hat deshalb keine Nachkommastellen und springt in Einerschritten. Wie du genauer rechnest, zeigt der übernächste Schritt.

Serieller Monitor mit Temperaturwerten in Grad Celsius — So sieht die Ausgabe im Seriellen Monitor aus

Sketch 1: Temperatur mit map() umrechnen

int LM35 = A0;      // Der Sensor wird am analogen Pin A0 angeschlossen. Wir nennen den Pin ab jetzt "LM35".
int sensorwert;     // Hier wird der rohe Messwert gespeichert.
int temperatur = 0; // Hier wird spaeter der umgerechnete Temperaturwert gespeichert.
int t = 500;        // Zeitlicher Abstand zwischen den Messungen in Millisekunden.

void setup()
{
  // Serielle Kommunikation starten, damit die Messwerte am Computer ankommen.
  // In der Arduino IDE oeffnest du dazu Werkzeuge -> Serieller Monitor.
  Serial.begin(9600);
}

void loop()
{
  // Auslesen des Sensorwertes
  sensorwert = analogRead(LM35);

  // Umwandeln des Sensorwertes mit Hilfe des map-Befehls
  temperatur = map(sensorwert, 0, 307, 0, 150);

  // Wert an den Seriellen Monitor senden
  Serial.print(temperatur);
  Serial.println(" Grad Celsius");

  // Pause bis zur naechsten Messung
  delay(t);
}

Erweiterung: Warnsignal ab 30 Grad

Jetzt soll ein Ton erklingen, sobald die Temperatur 30 °C erreicht. Dafür schließt du einen Piezo-Summer an: den Pluspol an Pin 5, den anderen Anschluss an GND.

Im Sketch prüft eine IF-Bedingung bei jedem Durchlauf, ob die gemessene Temperatur 30 erreicht oder überschreitet. Trifft das zu, erzeugt tone() einen Dauerton von 1000 Hertz; sinkt der Wert wieder, schaltet noTone() ihn ab.

Es gibt zwei Arten von Summern. Ein aktiver Summer hat seine eigene Tonerzeugung eingebaut und gibt auch bei einem einfachen digitalWrite(pin, HIGH) einen Ton aus. Ein passiver Piezo braucht dagegen ein Wechselsignal – bei ihm bleibt digitalWrite still, weshalb dieser Sketch tone() verwendet. Mit tone() funktionieren beide Bauformen.

Sketch 2: Warnsignal ab 30 Grad

int LM35 = A0;
int sensorwert;
int temperatur = 0;
int t = 500;
int piezo = 5;      // Das Wort "piezo" steht jetzt fuer die Zahl 5, der Summer haengt also an Pin 5.

void setup()
{
  Serial.begin(9600);

  // Der Pin fuer den Summer wird als Ausgang festgelegt.
  pinMode(piezo, OUTPUT);
}

void loop()
{
  sensorwert = analogRead(LM35);
  temperatur = map(sensorwert, 0, 307, 0, 150);

  Serial.print(temperatur);
  Serial.println(" Grad Celsius");

  // IF-Bedingung: Wenn die Temperatur 30 Grad erreicht oder ueberschreitet ...
  if (temperatur >= 30)
  {
    // ... soll ein Ton mit 1000 Hertz erklingen.
    tone(piezo, 1000);
  }
  // Und wenn das nicht so ist ...
  else
  {
    // ... bleibt es still.
    noTone(piezo);
  }

  delay(t);
}

Genauer rechnen statt mappen

Statt mit map() kannst du die Temperatur auch direkt ausrechnen – dann bleiben die Nachkommastellen erhalten. Der Rechenweg besteht aus zwei Schritten.

Zuerst wird aus der Zahl des Analog-Digital-Wandlers wieder eine Spannung. Der Arduino verteilt seine 5 Volt – also 5000 Millivolt – auf 1024 mögliche Werte. Der gemessene Zahlenwert wird deshalb mit 5000 multipliziert und durch 1024 geteilt.

Im zweiten Schritt wird aus der Spannung eine Temperatur. Weil 10 Millivolt genau einem Grad entsprechen, wird das Ergebnis noch durch 10 geteilt.

Serieller Monitor mit Temperaturwerten mit zwei Nachkommastellen — Ausgabe der berechneten Temperatur im Seriellen Monitor

Sketch 3: Temperatur direkt berechnen

// LM35 am analogen Eingang A0
int LM35 = A0;

// Der vom Analog-Digital-Wandler gelieferte Zahlenwert (0 bis 1023)
float digitalerWert;

// Daraus berechnete Spannung in Millivolt
float gemesseneSpannung;

// Daraus berechnete Temperatur in Grad Celsius
float gemesseneTemperatur;

void setup()
{
  // Seriellen Monitor starten
  Serial.begin(9600);
}

void loop()
{
  // Zahlenwert am Eingang A0 lesen
  digitalerWert = analogRead(LM35);

  // Verhaeltnis zwischen 5V (= 5000 mV am Arduino) und der
  // Anzahl der moeglichen Werte (1024) herstellen -> Spannung in Millivolt
  gemesseneSpannung = digitalerWert * 5000 / 1024;

  // Der LM35 liefert 10 mV je Grad, also durch 10 teilen -> Grad Celsius
  gemesseneTemperatur = gemesseneSpannung / 10;

  // Temperatur anzeigen
  Serial.print(gemesseneTemperatur);
  Serial.println(" Grad C");

  // 2 Sekunden Pause bis zur naechsten Messung
  delay(2000);
}

Zahlenformat ändern: Punkt durch Komma

Der Arduino trennt Nachkommastellen mit einem Punkt. Mit einer kleinen Ergänzung machst du daraus die im Deutschen übliche Schreibweise mit Komma.

Dazu wandelst du die Zahl zuerst in eine Zeichenkette um und ersetzt darin mit dem Befehl replace den Punkt durch ein Komma. Gerechnet wird weiterhin mit der ursprünglichen Zahl – nur die Anzeige ändert sich.

Sketch 4: Punkt durch Komma ersetzen

// LM35 am analogen Eingang A0
int LM35 = A0;

// Der vom Analog-Digital-Wandler gelieferte Zahlenwert (0 bis 1023)
float digitalerWert;

// Daraus berechnete Spannung in Millivolt
float gemesseneSpannung;

// Daraus berechnete Temperatur in Grad Celsius
float gemesseneTemperatur;

void setup()
{
  // Seriellen Monitor starten
  Serial.begin(9600);
}

void loop()
{
  // Zahlenwert am Eingang A0 lesen
  digitalerWert = analogRead(LM35);

  // Verhaeltnis zwischen 5V (= 5000 mV am Arduino) und der
  // Anzahl der moeglichen Werte (1024) herstellen -> Spannung in Millivolt
  gemesseneSpannung = digitalerWert * 5000 / 1024;

  // Der LM35 liefert 10 mV je Grad, also durch 10 teilen -> Grad Celsius
  gemesseneTemperatur = gemesseneSpannung / 10;

  // Zahlenwert in eine Zeichenkette (String) umwandeln
  String AnzeigeTemperatur = String(gemesseneTemperatur);

  // replace: Punkt durch Komma ersetzen
  AnzeigeTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.print(AnzeigeTemperatur);
  Serial.println(" Grad C");

  // 2 Sekunden Pause bis zur naechsten Messung
  delay(2000);
}

Ausgabe im Seriellen Monitor

Öffne in der Arduino IDE Werkzeuge → Serieller Monitor und stelle unten rechts 9600 Baud ein. Alle zwei Sekunden erscheint dann eine neue Zeile mit der gemessenen Temperatur.

Zum Ausprobieren hältst du den Fühler kurz in die Hand oder tauchst ihn – bei der wasserdichten Ausführung – in ein Glas mit warmem Wasser. Der Wert folgt der Änderung innerhalb weniger Sekunden.

Rate the instructions