Prendre la température

FunduinoDernière mise à jour le 04.01.2016

Analogwerte mit map() in Grad Celsius umrechnen

Aufgabe: Mit dem Temperatursensor TMP36 liest du die Temperatur aus und zeigst sie im Seriellen Monitor an. Anschließend erweiterst du den Sketch um ein Warnsignal, das bei 30 °C ertönt.

Schaltplan mit Temperatursensor TMP36 am analogen Pin A0 des Arduino UNO — Schaltplan: TMP36 am Arduino UNO

Den TMP36 anschließen

Der Sensor hat drei Anschlüsse. Beim Blick auf die flache Seite des Sensors:

links 5V
in der Mitte der Pin für das Temperatursignal
rechts GND

Auf dem Signalpin gibt der Sensor eine Spannung zwischen 0 V und 2,0 V aus: 0 V entsprechen -50 °C, 2,0 V entsprechen 150 °C. Laut Hersteller ist der Sensor zwischen -40 °C und +125 °C einigermaßen genau (±2 °C). Die Spannung dieses Pins liest das Mikrocontroller-Board aus und rechnet sie in einen Temperaturwert um.

Beim Aufbau solltest du nach Möglichkeit eine externe Stromversorgung verwenden (9V-Netzteil oder 9V-Batterie), denn das verbessert die Sensorgenauigkeit wesentlich.

ACHTUNG: Wenn du den Sensor falsch anschließt, brennt er durch. Prüfe die Belegung vor dem Einschalten.

Der map-Befehl – vom Messwert zur Temperatur

Für diesen Sketch brauchst du den map-Befehl. Er steht in der Zeile temperatur = map(sensorwert, 0, 410, -50, 150);

Anhand der allgemeinen Schreibweise map(a, b, c, d, e) lässt sich die Funktion verständlicher beschreiben: Ein Wert a – etwa ein Messwert – wird in einem bestimmten Zahlenbereich zwischen den zwei Werten b und c erwartet. Der map-Befehl wandelt den Wert a dann in einen anderen Wert um, der dem Zahlenbereich zwischen d und e entspricht.

a = umzuwandelnde Zahl
b = Minimum des Messbereichs
c = Maximum des Messbereichs
d = Minimum des Ausgabewerts
e = Maximum des Ausgabewerts

In unserem Sketch passiert dabei Folgendes: Der TMP36 gibt am mittleren Pin den Messwert als Spannung zwischen 0 V und 2 V aus. Dieser Spannungsbereich entspricht dem messbaren Temperaturbereich von -50 °C bis +150 °C. Am analogen Eingangspin des Arduino-Boards wird dieser Spannungsbereich mit dem Befehl analogRead(TMP36) als Zahlenwert zwischen 0 und 410 erkannt und unter der Variablen sensorwert gespeichert. Der map-Befehl wandelt diesen Zahlenwert wieder in einen Temperaturwert zwischen -50 °C und +150 °C um.

Den fertigen Temperaturwert sendest du anschließend mit Serial.print(temperatur); an den Seriellen Monitor und liest ihn am PC ab.

Temperatur auslesen und anzeigen

Nach dem Öffnen des Seriellen Monitors sollte das Ergebnis so aussehen wie auf dem Bild.

Ausgabe im Seriellen Monitor mit Temperaturwerten und der Einheit Grad Celsius — Die erfassten Temperaturwerte im Seriellen Monitor

Programmcode – Temperatur auslesen und anzeigen

int TMP36 = A0; // Der Sensor wird am analogen Pin A0 angeschlossen. Wir nennen den Pin ab jetzt "TMP36".
int sensorwert;
int temperatur = 0; // Unter der Variablen "temperatur" wird später der Temperaturwert abgespeichert.
int t = 500; // Der Wert für "t" gibt die zeitlichen Abstände zwischen den einzelnen Messungen vor.
void setup()
{
  Serial.begin(9600); // Im Setup beginnt die serielle Kommunikation, damit die Temperatur an den Seriellen Monitor übertragen wird. Über die serielle Kommunikation sendet das Board die Messwerte an den Computer. In der Arduino-Software startest du unter "Werkzeuge" den "Seriellen Monitor", um die Messwerte zu sehen.
}
void loop()
{
  sensorwert = analogRead(TMP36); // Auslesen des Sensorwertes.
  temperatur = map(sensorwert, 0, 410, -50, 150); // Umwandeln des Sensorwertes mit Hilfe des "map"-Befehls.
  delay(t); // Nach jeder Messung folgt eine kleine Pause mit der Dauer "t" in Millisekunden.
  Serial.print(temperatur); // Nun wird der Wert "temperatur" über die serielle Kommunikation an den PC gesendet.
  Serial.println(" Grad Celsius"); // Im Seriellen Monitor wird hinter der Temperatur die Einheit eingeblendet.
}

Erweiterung: Warnsignal bei Temperaturüberschreitung

Sobald die Temperatur 30 °C erreicht, soll ein Warnsignal ertönen. Dazu schließt du einen Lautsprecher mit dem Plus-Pol an Pin 5 des Arduino-Boards an. Den anderen Pin des Lautsprechers verbindest du mit GND.

Dieser Sketch schaltet den Lautsprecher mit digitalWrite dauerhaft ein. Das erzeugt nur bei einem aktiven Buzzer einen Ton – ein passiver Lautsprecher bleibt dabei stumm. Mit einem passiven Lautsprecher verwendest du stattdessen den Befehl tone().

Programmcode – Warnsignal bei Temperaturüberschreitung

int TMP36 = A0;
int sensorwert;
int temperatur = 0;
int t = 500;
int piezo = 5; // Das Wort "piezo" steht jetzt für die Zahl 5, an Pin 5 wird also der Lautsprecher angeschlossen.
void setup()
{
  Serial.begin(9600);
  pinMode(piezo, OUTPUT); // Der Pin für den Lautsprecher wird als Ausgang definiert, da zum Piepsen eine Spannung nötig ist.
}
void loop()
{
  sensorwert = analogRead(TMP36);
  temperatur = map(sensorwert, 0, 410, -50, 150);
  delay(t);
  Serial.print(temperatur);
  Serial.println(" Grad Celsius");
  if (temperatur >= 30) // Eine IF-Bedingung: Wenn der Wert für die Temperatur größer oder gleich 30 ist, dann ...
  {
    digitalWrite(piezo, HIGH); // ... fange an zu piepsen.
  }
  else // Und wenn das nicht so ist ...
  {
    digitalWrite(piezo, LOW); // ... dann sei leise.
  }
}

Évaluer le guide