Nr. 10 – Temperatur messen (NodeMCU)

Inhaltsverzeichnis

Einen TMP36 Temperatursensor am NodeMCU verwenden

Pinout

Der Sensor verfügt über drei Anschlüsse (bei Blick auf die flache Seite des Sensors):

  • links VCC – 5V
  • rechts GND – Ground
  • mittig – Signalübertragung

Auf dem SIgnalpin gibt der Sensor eine Spannung zwischen 0 und 2,0 Volt aus. Wobei 0V -50 °C entsprechen und der Wert 2,0V entspricht 150 °C. Laut Hersteller ist der Sensor zwischen -40 °C und +125 °C einigermaßen genau (±2 °C). 

Die Spannung dieses Pins muss vom Mikrocontroller-Board ausgelesen und in einen Temperaturwert umgerechnet werden. ACHTUNG: Wenn der Sensor falsch angeschlossen wird, brennt er durch! Bei dem Aufbau sollte nach Möglichkeit eine externe Stromversorgung verwendet werden, da dies die Sensorgenauigkeit wesentlich verbessert (9V Netzteil oder 9V-Batterie).

Der Aufbau

Die Programmierung

Für diesen Sketch wird der „map“ Befehl benötigt. Dieser Befehl befindet sich in der Zeile: „temperatur= map(analogRead(TMP36), 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 dann den Wert „a“ in einen anderen Wert um, der dem Zahlenbereich zwischen „d“ und „e“ entspricht. 

In unserem Sketch passiert dabei Folgendes:

Der Temperatursensor TMP36 gibt an dem mittleren Pin den Messwert für die Temperatur in Form einer Spannung zwischen 0V und 2V aus. Dieser Spannungsbereich entspricht dem messbaren Temperaturbereich von -50 °C bis +150 °C. Am analogen Eingangspin des Arduino Mikrocontrollerboards wird dieser Spannungsbereich mithilfe des Befehls „analogRead(TMP36)“ als Zahlenwert zwischen 0 und 410 erkannt. Dieser Wert des Temperatursensors wird zunächst ausgelesen und unter der Variablen „sensorwert“ gespeichert.

Der „map“ Befehl wird nun verwendet, um diesen Zahlenwert zwischen 0 und 410 wieder 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= umzuwandelnde Zahl

b= minimum Messbereich

c= maximum Messbereich

d= minimum Ausgabewert

e= maximum Ausgabewert

Nach der Umwandlung des analogen Messwertes in einen Temperaturwert wird dieser mit dem Befehl „Serial.print(temperatur);“ an den seriellen Monitor gesendet und kann dann am PC abgelesen werden.

Der Sketch

int TMP36 = A0; //Der Sensor soll am analogen Pin A0 angeschlossen werden. 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 im Code 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 serial monitor übertragen wird. Über die serielle Kommunikation sendet das Board die Messwerte an den Computer. In der Arduino-Software kann man unter „Werkzeuge“ den „Seriellen Monitor“ starten 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 ist je 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. 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.
}

Nach dem Öffnen des seriellen Monitors sollte das Ergebnis so aussehen:

Erweiterter Sketch

Sobald die Temperatur von 30 °C erreicht ist, soll ein Warnsignal ertönen. Dazu wird ein Piezo-Lautsprecher mit dem „+“ Pol an Pin D5  des NodeMCU angeschlossen. Der andere Pin des Lautsprechers wird mit GND verbunden.

int TMP36 = A0; 
int sensorwert;
int temperatur = 0;
int t=500;
int piezo=D5; //Das Wort „piezo“ steht jetzt für die Zahl 5, also wird an Pin5 der Speaker angeschlossen.

void setup() 
{
Serial.begin(9600);
pinMode (piezo, OUTPUT); //Der Pin für den Piezo-Lautsprecher wird als Ausgang definiert, da hier um zu piepsen eine Spannung benötigt wird.
}

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

if (temperatur>=30) //Es wird eine IF-Bedingung erstellt: Wenn der Wert für die Temperatur über oder gleich 30 ist, dann…
{
digitalWrite(piezo,HIGH); //…fange an zu piepsen.
}

else //Und wenn das nicht so ist…
{
digitalWrite(piezo,LOW); //…dann sein leise.
}
}

Funduino - Dein Onlineshop für Mikroelektronik

  • Dauerhaft 10% Rabatt für Schüler, Studenten und Lehrkräfte
  • Mehr als 2.000 Artikel sofort verfügbar!
  • Über 8 Jahre Erfahrung mit Arduino, 3D-Druck und co.
SALE