Temperaturen mit einem TMP36

1.Einführung

Aufgabe: Mit dem Temperatursensor TMP36 soll die Temperatur gemessen und im Serial Monitor angezeigt werden.Der Sensor hat drei Anschlüsse. Wenn man die flache Seite des Sensors betrachtet:

links --> 5V

rechts --> GND

in der Mitte der Pin für das Temperatursignal

Am Signalpin gibt der Sensor eine Spannung zwischen 0 und 2,0 Volt aus. Dabei entspricht 0V -50 °C und 2,0V entsprechen 150 °C. Laut Herstellerangaben ist der Sensor zwischen -40 °C und +125 °C relativ genau (±2 °C). Die Spannung dieses Pins muss vom Mikrocontroller-Board gemessen und in einen Temperaturwert umgerechnet werden.

ACHTUNG: Falls der Sensor falsch angeschlossen wird, kann er durchbrennen!

Es wird empfohlen, eine externe Stromversorgung zu verwenden, um die Genauigkeit des Sensors zu verbessern (9V Netzteil oder 9V-Batterie).

2.Schaltpläne

2.1.Arduino UNO

Der "map"-Befehl wird in diesem Programm verwendet, um den Messwert des Temperatursensors (TMP36) in einen verständlichen Temperaturwert umzuwandeln. In der Zeile "temperatur = map(analogRead(TMP36), 0, 410, -50, 150);" wird dies konkret gemacht.

Die Idee hinter "map(a, b, c, d, e)" ist, dass ein Wert "a" (zum Beispiel ein Messwert) erwartet wird, der in einem bestimmten Zahlenbereich zwischen den beiden Werten "b" und "c" liegt. Der "map"-Befehl wandelt dann diesen Wert "a" in einen anderen um, der in den Zahlenbereich zwischen "d" und "e" passt.

In unserem Programm gibt der Temperatursensor über seinen mittleren Pin einen Messwert in Form einer Spannung zwischen 0V und 2V aus. Dieser Spannungsbereich entspricht einem Temperaturbereich von -50 °C bis +150 °C. Mithilfe von "analogRead(TMP36)" wird dieser Spannungsbereich als Zahlenwert zwischen 0 und 410 auf dem Arduino-Mikrocontroller erfasst. Dieser Wert wird als "sensorwert" gespeichert.

Dann wird der "map"-Befehl verwendet, um diesen Zahlenwert zwischen 0 und 410 in einen Temperaturwert zwischen -50 °C und +150 °C umzuwandeln:

temperatur = map(sensorwert, 0, 410, -50, 150);

temperatur = map(a, b, c, d, e)

a = zu konvertierende Zahl

b = Minimum des Messbereichs

c = Maximum des Messbereichs

d = Minimum des Ausgabewerts

e = Maximum des Ausgabewerts

Nach dieser Umwandlung wird der Temperaturwert mit "Serial.print(temperatur);" an den seriellen Monitor gesendet und kann am PC abgelesen werden.

3.Die Programmcode

2.1.Arduino UNO

int TMP36 = A0;        // Der Sensor wird am analogen Pin A0 angeschlossen und wird fortan als "TMP36" bezeichnet.
int sensorwert;        // Der Sensorwert wird hier gespeichert.
int temperatur = 0;    // Unter der Variable "temperatur" wird später der Temperaturwert abgelegt.
int t = 500;           // Der Wert für "t" legt im Code die zeitlichen Abstände zwischen den einzelnen Messungen fest.

void setup() {
  Serial.begin(9600);  // Im Setup wird die serielle Kommunikation gestartet, damit die Temperatur an den Serial Monitor übertragen wird. Über die serielle Kommunikation sendet das Board die Messwerte an den Computer. In der Arduino-Software kann unter "Werkzeuge" der "Serielle Monitor" gestartet werden, um die Messwerte zu sehen.
}

void loop() {
  sensorwert = analogRead(TMP36);                   // Sensorwert auslesen.
  temperatur = map(sensorwert, 0, 410, -50, 150);    // Sensorwert mit Hilfe des "map"-Befehls umwandeln.
  delay(t);                                          // Nach jeder Messung gibt es eine kurze Pause mit der Dauer "t" in Millisekunden.
  Serial.print(temperatur);                          // Nun wird der Wert "temperatur" über die serielle Kommunikation an den PC gesendet. Durch Öffnen des seriellen Monitors in der Arduino-Software kann die Temperatur abgelesen werden.
  Serial.println(" Grad Celsius");                   // Im seriellen Monitor wird hinter der Temperatur die Einheit eingeblendet.
}

Wenn man seriell Monitor öffnet, sollte das Ergebnis so aussehen:

Erweiterung des Codes für ein Warnsignal bei hoher Temperatur:

Wenn die Temperatur 30 °C erreicht, soll ein Alarm ausgelöst werden. Dafür schließen wir einen Piezo-Lautsprecher mit dem Pluspol an Pin 5 des Arduino-Boards an, während der andere Pin mit GND verbunden wird.

Die Programmcode:

int TMP36 = A0; 
int sensorwert;
int temperatur = 0;
int t = 500;
int piezoPin = 5;  // Der Lautsprecher ist jetzt am Pin 5 (piezoPin) angeschlossen.

void setup() 
{
  Serial.begin(9600);
  pinMode(piezoPin, OUTPUT);  // Der Pin für den Lautsprecher wird als Ausgang festgelegt, weil er eine Spannung zum Piepsen benötigt.
}

void loop() 
{
  sensorwert = analogRead(TMP36); 
  temperatur = map(sensorwert, 0, 410, -50, 150);
  delay(t);
  Serial.print(temperatur);
  Serial.println(" Grad Celsius");

  if (temperatur >= 30)  // Wenn die Temperatur 30 oder höher ist, dann...
  {
    digitalWrite(piezoPin, HIGH);  // ...fang an zu piepsen.
  }
  else  // Und wenn das nicht der Fall ist...
  {
    digitalWrite(piezoPin, LOW);  // ...sei leise.
  }
}