In diesem Tutorial lernst du, wie man einen TMP36 analogen Temperatursensor mit Arduino verwendet. Ich habe ein Schaltbild und mehrere Beispielcodes beigefügt, die dir den Einstieg erleichtern!
Im ersten Teil dieses Artikels findest du die Spezifikationen und Informationen zu den Sensoren TMP35, TMP36 und TMP37. Anschließend schauen wir uns an, wie man den Sensor mit dem Arduino verbindet.
Das erste Codebeispiel kann verwendet werden, um Temperaturmessungen vom Sensor zu nehmen und die Ergebnisse im Serial Monitor anzuzeigen. Im zweiten Beispiel zeige ich dir, wie du die Temperatur auf einem I2C LCD anzeigen kannst, um ein eigenständiges Thermometer zu erstellen.
Materialien
Hardware-Komponenten
| TMP36 analog temperature sensor (TO-92) | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon |
| 16×2 character I2C LCD | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Über die analogen Temperatursensoren TMP35/TMP36/TMP37
Die TMP35/TMP36/TMP37 sind Niederspannungs-Präzisions-Temperatursensoren in Grad Celsius, hergestellt von Analog Devices. Sie liefern eine Spannungsausgabe, die linear proportional zur Temperatur in Grad Celsius (°C) ist und sind daher sehr einfach mit dem Arduino zu verwenden. Außerdem sind sie präzise, verschleißen nicht und sind sehr preiswert!
Die TMP35/TMP36/TMP37 Sensoren benötigen keine externe Kalibrierung, um eine typische Genauigkeit von ±1°C bei +25°C und ±2°C im Temperaturbereich von −40°C bis +125°C zu erreichen.
Der Unterschied zwischen TMP35, TMP36 und TMP37 liegt im Temperaturarbeitsbereich und im Ausgangsmaßstab. Der TMP35 misst Temperaturen von 10°C bis 125°C und liefert bei 25°C eine Ausgangsspannung von 250 mV. Dieser Sensor ist funktional kompatibel mit dem LM35 von Texas Instruments. Siehe das LM35 analog temperature sensor with Arduino Tutorial für weitere Details.
Der TMP36 misst Temperaturen von -40°C bis 125°C, liefert bei 25°C eine Ausgangsspannung von 750 mV und arbeitet bis +125°C mit einer einzigen 2,7 V Versorgungsspannung. Dieser Sensor ist funktional kompatibel mit dem LM50. TMP35 und TMP36 haben denselben Ausgangsmaßstab von 10 mV/°C.
Der TMP37 ist für einen Arbeitsbereich von 5°C bis 100°C vorgesehen und liefert bei 25°C eine Ausgangsspannung von 500 mV. Dieser Sensor bietet eine etwas höhere Präzision als die anderen Sensoren und hat einen Ausgangsmaßstab von 20 mV/°C.
Wie in der Abbildung oben zu sehen ist, liegt der Ausgangsbereich aller Sensoren zwischen 0,1 V und 2 V. Beachte, dass die Ausgangsspannung unabhängig von der verwendeten Versorgungsspannung ist.
Pinbelegung TMP35/TMP36/TMP37
Die TMP35/TMP36/TMP37 Sensoren gibt es in 3 verschiedenen Bauformen, aber der gebräuchlichste Typ ist der 3-pin TO-92 package, der wie ein Transistor aussieht. Die TMP36-Version dieses Sensors trägt die Modellnummer TMP36GT9Z.
Die Pinbelegung des Sensors ist in der folgenden Abbildung dargestellt:
Beachte, dass Pin 1 (+VS) der linke Pin ist, wenn die flache Seite des Sensors (mit dem aufgedruckten Text) zu dir zeigt.
Weitere Spezifikationen des TMP36 findest du in der folgenden Tabelle.
Spezifikationen des TMP36 analogen Temperatursensors
| Versorgungsspannung | 2,7 V bis 5,5 V |
| Ruhe-Stromaufnahme | 50 µA |
| Temperaturbereich | -40°C bis +125°C |
| Genauigkeit | ±1°C bei +25°C ±2°C von -40°C bis +125°C |
| Ausgangsmaßstab | 10 mV/°C |
| Ausgangsspannung bei 25°C | 750 mV |
| Gehäuse | 3-poliges TO-92 |
| Hersteller | Analog Devices |
| Kosten | Check price |
Weitere Informationen findest du auch im Datenblatt hier:
Verdrahtung – Anschluss des TMP36 Temperatursensors an Arduino
Den TMP36 an den Arduino anzuschließen ist sehr einfach, da du nur 3 Pins verbinden musst. Beginne damit, den +VS Pin mit dem 5 V Ausgang des Arduino und den GND Pin mit Masse zu verbinden. Wenn du einen 3,3 V Arduino verwendest, verbinde +VS stattdessen mit 3,3 V.
Als nächstes verbinde den mittleren Pin (VOUT) mit einem der analogen Eingänge des Arduino. In diesem Fall habe ich den analogen Eingang A0 verwendet.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:
Anschlüsse des TMP36 analogen Temperatursensors
| TMP36 | Arduino |
|---|---|
| Pin 1 (+VS) | 5 V |
| Pin 2 (VOUT) | Pin A0 |
| Pin 3 (GND) | GND |
Um die Stabilität des Sensors zu verbessern, empfiehlt das Datenblatt, einen 0,1 μF Keramikkondensator zwischen +VS Pin und GND zu schalten. Wenn du lange Kabel verwendest, kann auch ein kleiner Widerstand (z. B. 750 Ω) in Serie zur Signalleitung (VOUT) das Rauschen reduzieren.
Als ich den Sensor mit einem Arduino Uno getestet habe, erhielt ich stabile Messwerte ohne Kondensator und Widerstand, aber deine Ergebnisse können variieren.
Umwandlung der TMP36 Ausgangsspannung in Temperatur
Um die Ausgangsspannung des Sensors in die Temperatur in Grad Celsius umzuwandeln, kannst du folgende Formel verwenden:
Temperatur (°C) = (VOUT – 500) / 10
wobei VOUT in Millivolt (mV) angegeben ist. Wenn die Ausgangsspannung des Sensors also 750 mV beträgt, ist die Temperatur:
(750 – 500) / 10 = 25°C
Wie im Schaltplan oben zu sehen ist, ist der Ausgang des TMP36 mit einem der analogen Eingänge des Arduino verbunden. Der Wert dieses analogen Eingangs kann mit der Funktion analogRead() ausgelesen werden, wie du in den folgenden Codebeispielen sehen wirst. Allerdings gibt die Funktion analogRead(pin) nicht direkt die Ausgangsspannung des Sensors zurück.
Arduino-Boards enthalten einen mehrkanaligen 10-Bit Analog-Digital-Wandler (ADC), der Eingangsspannungen zwischen 0 und der Betriebsspannung (5 V oder 3,3 V) in Ganzzahlen zwischen 0 und 1023 umwandelt. Bei einem Arduino Uno entspricht das einer Auflösung von 5 Volt / 1024 Einheiten oder 0,0049 Volt (4,9 mV) pro Einheit.
Wenn du also analogRead() verwendest, um die Spannung an einem der analogen Eingänge des Arduino zu messen, erhältst du einen Wert zwischen 0 und 1023.
Um diesen Wert wieder in die Ausgangsspannung des Sensors umzuwandeln, kannst du folgende Formel verwenden:
VOUT = Wert vom ADC * (5000 / 1024)
Und wenn du einen 3,3 V Arduino verwendest:
VOUT = Wert vom ADC * (3300 / 1024)
Diese Formeln verwenden wir in den folgenden Codebeispielen.
Beispielcode für TMP36 analogen Temperatursensor mit Arduino
Mit dem folgenden Beispielcode kannst du die Temperatur von einem TMP36 Sensor auslesen und im Serial Monitor anzeigen.
/* TMP36 analog temperature sensor with Arduino example code.
https://www.makerguides.com */
// Define to which pin of the Arduino the output of the TMP36 is connected:
#define sensorPin A0
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (5000 / 1024.0);
// Convert the voltage into the temperature in Celsius:
float temperature = (voltage - 500) / 10;
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
delay(1000); // wait a second between readings
}
Im Serial Monitor (Strg + Shift + M) solltest du folgende Ausgabe sehen.
Stelle sicher, dass die Baudrate des Serial Monitors ebenfalls auf 9600 eingestellt ist.
Wie der Code funktioniert
Zuerst habe ich definiert, an welchen Pin des Arduino der VOUT Pin des Sensors angeschlossen ist. In diesem Fall haben wir den analogen Pin A0 verwendet. Die Anweisung #define kann verwendet werden, um einem konstanten Wert einen Namen zu geben. Der Compiler ersetzt alle Verweise auf diese Konstante durch den definierten Wert, wenn das Programm kompiliert wird. Überall, wo du sensorPin erwähnst, ersetzt der Compiler es beim Kompilieren durch A0.
// Define to which pin of the Arduino the output of the TMP36 is connected: #define sensorPin A0
Im Setup-Teil des Codes starten wir die serielle Kommunikation mit einer Baudrate von 9600.
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
Im Loop-Teil des Codes beginnen wir damit, eine Messung vom Sensor mit der Funktion analogRead(pin) vorzunehmen.
// Get a reading from the temperature sensor: int reading = analogRead(sensorPin);
Anschließend verwenden wir die Formeln, die ich zuvor im Artikel erwähnt habe, um die Messung in Spannung und dann in Temperatur umzuwandeln.
// Convert the reading into voltage: float voltage = reading * (5000 / 1024.0); // Convert the voltage into the temperature in degree Celsius: float temperature = (voltage - 500) / 10;
Wenn du einen 3,3 V Arduino verwendest, wie den Arduino Due oder Arduino Nano 33 BLE, musst du den +VS Pin mit 3,3 V verbinden und die markierte Zeile durch folgende ersetzen:
// Convert the reading into voltage: float voltage = reading * (3300 / 1024.0);
Zuletzt werden die Ergebnisse im Serial Monitor ausgegeben:
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
Anzeige der TMP36 Temperaturwerte auf einem I2C LCD
Wenn du ein eigenständiges Thermometer bauen möchtest, das keinen Computer benötigt, ist es praktisch zu wissen, wie man die Temperaturwerte auf einem LCD-Display anzeigen kann.
Mit dem Beispielcode unten kannst du die Temperaturwerte auf einem 16×2 Zeichen I2C LCD anzeigen. Das Anschließen des I2C LCD ist ziemlich einfach, wie du im Schaltplan unten sehen kannst.
Siehe das How to control a character I2C LCD with Arduino und das How to use a 16×2 character LCD with Arduino Tutorial für weitere Details zu I2C LCD Displays.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt:
Anschlüsse des I2C LCD
| I2C Zeichen LCD | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Beachte, dass der TMP36 Temperatursensor wie zuvor angeschlossen ist.
Installation der benötigten Arduino-Bibliotheken
Um ein I2C LCD zu verwenden, musst du die LiquidCrystal_I2C Arduino-Bibliothek installieren.
Um diese Bibliothek zu installieren, gehe im Arduino IDE zu Tools > Manage Libraries (Strg + Shift + I unter Windows). Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.
Suche nun nach „liquidcrystal_i2c“ und suche die Bibliothek von Frank de Brabander. Wähle die neueste Version aus und klicke dann auf Installieren.
Beispielcode für TMP36 mit I2C LCD
/* TMP36 analog temperature sensor with I2C LCD and Arduino example code.
https://www.makerguides.com */
// Include the required Arduino libraries:
#include "LiquidCrystal_I2C.h"
// Create a new instance of the LiquidCrystal_I2C class:
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Degree symbol:
byte Degree[] = {
B00111,
B00101,
B00111,
B00000,
B00000,
B00000,
B00000,
B00000
};
// Define to which pin of the Arduino the TMP36 is connected:
#define sensorPin A0
void setup() {
// Start the LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create a custom character:
lcd.createChar(0, Degree);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (5000 / 1024.0);
// Convert the voltage into the temperature in degree Celsius:
float temperature = (voltage - 500) / 10;
// Print the temperature on the LCD;
lcd.setCursor(0, 0);
lcd.print("Temperature:");
lcd.setCursor(0, 1);
lcd.print(temperature);
lcd.write(0); // print the custom character
lcd.print("C");
delay(1000); // wait a second between readings
}
Du solltest folgende Ausgabe auf dem LCD sehen:
Fazit
In diesem Tutorial habe ich dir gezeigt, wie du einen TMP36 analogen Temperatursensor mit Arduino verwendest. Wenn du mehr über andere Temperatursensoren erfahren möchtest, schau dir die untenstehenden Artikel an.
- The complete guide for DS18B20 digital temperature sensors with Arduino
- How to use DHT11 and DHT22 Sensors with Arduino
- LM35 analog temperature sensor with Arduino tutorial
- How to control a character I2C LCD with Arduino
- How to use a 16×2 character LCD with Arduino
Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.
