Temperatursensoren für Arduino: 8 Sensoren im großen Vergleich

Bei den vielen Temperatursensoren für Arduino die richtige Wahl zu treffen, ist wichtiger, als es zunächst scheint: Ein DHT11 und ein DS18B20 im selben Raum können 2 °C auseinanderliegen, und wer einen 300 °C heißen Ofen mit dem falschen Sensor messen will, kann ihn schlicht schmelzen. In der Hobbyelektronik dominieren acht Temperatursensoren: DHT11, DHT22, DS18B20, LM35, der NTC-Thermistor, BME280, MAX6675 (Thermoelement Typ K) und MLX90614 (berührungslos, Infrarot). Jeder hat einen anderen Messbereich, eine andere Genauigkeit, Anschlussart und Preisklasse. Welcher der richtige ist, hängt davon ab, was du messen willst: Raumluft, Wasser, einen Ofen oder einen drehenden Motor, den du nicht berühren kannst?

In diesem Ratgeber stellen wir die acht Sensoren in zwei großen Tabellen nebeneinander: Messbereich, Genauigkeit, Auflösung, Messrate, Schnittstelle, Versorgungsspannung, Kabellänge und relativer Preis. Danach erfährst du, wie jeder funktioniert, wo seine Stärken und Schwächen liegen und wie du ihn an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt. Dazu bekommst du Beispielcode für NTC, MAX6675 und MLX90614, einen Testaufbau, der drei Sensoren gegeneinander antreten lässt, und eine Übersicht, welcher Sensor zu welchem Projekt passt. Zu den meisten Sensoren gibt es auch ausführliche Anleitungen; die Links findest du in den passenden Abschnitten.

Worauf solltest du bei der Wahl eines Temperatursensors achten?

Bevor du Sensoren vergleichst, musst du die Begriffe im Datenblatt richtig lesen. Am häufigsten verwechselt werden Genauigkeit und Auflösung. Die Genauigkeit sagt, wie nah dein Messwert an der echten Temperatur liegt; die Auflösung ist der kleinste Schritt, den der Sensor unterscheiden kann. Der BME280 liefert die Temperatur in Schritten von 0,01 °C, seine Genauigkeit liegt aber bei etwa ±1 °C. Die letzten beiden Stellen der 23,47 °C auf deinem Display helfen also, kleine Änderungen zu verfolgen, verraten dir die echte Temperatur aber nicht so genau. Achte bei der Auswahl auf diese sieben Kriterien:

• Messbereich: Der Sensor sollte die niedrigste und höchste Temperatur, die du messen willst, bequem abdecken. Der DHT11 sieht nichts unter null; für den Kühlschrank brauchst du einen DS18B20, für den Ofen ein Thermoelement.
• Genauigkeit: Für ein Raumthermometer sind ±2 °C in Ordnung, ein Aquarium oder ein Brutapparat braucht dagegen ±0,5 °C.
• Schnittstelle: Analoge Sensoren brauchen einen ADC-Pin, digitale einen oder mehrere digitale Pins und meist eine Bibliothek. Wie viele Pins auf deinem Board frei sind, bestimmt, wie viele Sensoren du anschließen kannst.
• Kabellänge: Sitzt der Sensor 5 Meter vom Board entfernt, im Garten oder am Boden eines Wassertanks, kommen analoge und I2C-Sensoren an ihre Grenzen; 1-Wire und das Eindrahtprotokoll der DHTs vertragen lange Leitungen deutlich besser.
• Ansprechzeit: Ein Fühler in einer Edelstahlhülse oder ein DHT im Kunststoffgehäuse erfasst einen plötzlichen Temperaturwechsel erst nach Sekunden oder sogar Minuten; ein kleiner, blanker NTC ist viel schneller.
• Zusätzliche Messwerte: Brauchst du auch die Luftfeuchtigkeit, reicht ein DHT22 oder BME280; brauchst du außerdem Luftdruck und Höhe, erledigt der BME280 alles in einem Modul.
• Versorgungsspannung: Beim ESP32 und Pico mit 3,3 V musst du auf Sensoren wie den LM35 achten, die mindestens 4 V brauchen, und darauf, dass am ADC-Eingang nie mehr als 3,3 V ankommen.

Vergleichstabelle: 8 Temperatursensoren

Die erste Tabelle fasst die Messleistung zusammen, die zweite Anschluss und Kosten. Die Werte stammen aus den Datenblättern; wenn nicht anders angegeben, gilt die Genauigkeit um Raumtemperatur und wird zu den Bereichsgrenzen hin schlechter.

DHT11 und DHT22: Temperatur und Luftfeuchtigkeit zusammen

Im Kunststoffgitter eines DHT-Sensors stecken ein Feuchteelement (resistiv beim DHT11, kapazitiv beim DHT22), ein Thermistor und ein kleiner Controller, der die Messwerte digitalisiert. Der Sensor schickt sein Ergebnis über eine einzige Datenleitung als 40-Bit-Paket: 16 Bit Feuchte, 16 Bit Temperatur und 8 Bit Prüfsumme. Das ist kein 1-Wire, sondern ein eigenes Eindrahtprotokoll des Herstellers; deshalb braucht jeder DHT einen eigenen Pin. Der DHT11 ist billig und reicht für die Raumtemperatur, doch sein Bereich von 0–50 °C und der Fehler von ±2 °C machen ihn für draußen und genaue Aufgaben schwach. Mit derselben Verdrahtung misst der DHT22 (AM2302) von −40 bis +80 °C mit ±0,5 °C Genauigkeit und liefert die Luftfeuchtigkeit von 0–100 %; dafür schafft er nur eine Messung alle zwei Sekunden. Beide teilen eine Schwäche, die Trägheit: Sie zeigen Änderungen spät an, weil die Luft im Gitter erst ins Gleichgewicht mit der Umgebung kommen muss. Anschluss, Bibliothek und Code findest du im Artikel DHT11 Temperatur- und Feuchtigkeitssensor; derselbe Code läuft mit dem DHT22, wenn du ein einziges Wort änderst.

DS18B20: wasserdicht, robust und viele Sensoren an einem Pin

Der DS18B20 misst die Temperatur im Chip und sendet sie als digitale Zahl mit wählbarer Auflösung von 9 bis 12 Bit. Er misst von −55 bis +125 °C, ist zwischen −10 und +85 °C auf ±0,5 °C genau, und dank des 1-Wire-Protokolls kannst du Dutzende Sensoren an einen einzigen Datenpin hängen; jeder hat eine ab Werk einprogrammierte, eindeutige 64-Bit-Adresse. Die wasserdichte Fühlerversion in der Edelstahlhülse ist unschlagbar für Aquarium, Wassertank, Heizungsrohre, Erde und Gefrierschrank. Seine einzige Bedingung ist ein 4,7-kΩ-Pull-up-Widerstand zwischen Datenleitung und Versorgung; fehlt er, liefert die Bibliothek −127 °C. Im 12-Bit-Modus dauert eine Messung 750 ms, daher musst du die Auflösung eventuell senken, um schnell wechselnde Temperaturen zu verfolgen. Den Code für mehrere Sensoren und das nicht blockierende Auslesen am ESP32 findest du im Artikel DS18B20-Temperatursensor.

LM35: der einfachste Analogsensor, ganz ohne Bibliothek

Der LM35 wandelt die Temperatur direkt in eine Spannung um: Sein Ausgang steigt pro Grad um 10 mV und liefert bei 25 °C 250 mV. Eine Bibliothek brauchst du nicht; das Ergebnis erhältst du mit der Formel Temperatur = analogRead × 5,0 / 1024 × 100. Diese Einfachheit macht ihn zum perfekten Einstieg, um den ADC kennenzulernen. Seine Schwächen haben denselben Ursprung: Mit 5-V-Referenz liefert der 10-Bit-ADC des Arduino Uno nur Schritte von etwa 0,49 °C, jede Abweichung der 5 V vom USB geht direkt in die Temperatur ein, und je länger das Kabel, desto mehr Störungen fängt der Ausgang ein. Die meisten LM35 im Handel sind LM35DZ und nur für 0–100 °C garantiert. Außerdem braucht er mindestens 4 V und muss am ESP32 und Pico deshalb am 5-V-Pin hängen. An 3,3-V-Boards ist der TMP36 die praktischere analoge Alternative: Er arbeitet mit 2,7–5,5 V, misst −40 bis +125 °C und liefert ebenfalls 10 mV/°C, gibt bei 0 °C aber schon 500 mV aus, daher lautet die Formel Temperatur = (V − 0,5) × 100. Seine typische Genauigkeit liegt bei ±1 °C bei 25 °C und ±2 °C über den gesamten Bereich. Wie du die Schrittweite mit der internen 1,1-V-Referenz auf 0,11 °C senkst, erklären wir Schritt für Schritt im Artikel LM35-Temperatursensor; wie der ADC funktioniert, erfährst du unter Analog-Digital-Wandlung.

NTC-Thermistor: der günstigste und schnellste Sensor

Ein NTC-Thermistor (Negative Temperature Coefficient, Heißleiter) ist ein Widerstand, dessen Widerstandswert mit steigender Temperatur sinkt. Am häufigsten ist in Bastelprojekten der Typ mit 10 kΩ bei 25 °C und einem B-Wert von 3950 K. Da der Arduino Widerstände nicht direkt messen kann, wird der NTC zusammen mit einem Festwiderstand als Spannungsteiler geschaltet, und die Spannung am Mittelpunkt wird über einen Analogpin gelesen. Diese Schaltung hat einen schönen Vorteil: Wird der Teiler aus derselben 5-V-Spannung versorgt, die auch die ADC-Referenz bildet, ist die Messung ratiometrisch; das Ergebnis ändert sich nicht, selbst wenn die Versorgung 4,8 oder 5,1 V beträgt. Die Spannungen im Teiler berechnest du bequem mit dem Spannungsteiler-Rechner.

Der Widerstand eines NTC ändert sich mit der Temperatur nicht linear, sondern exponentiell; deshalb reicht kein einfacher Faktor wie beim LM35. In der Praxis nutzt man die Beta-Gleichung: 1/T = 1/T0 + (1/B) × ln(R/R0). Dabei ist T die Temperatur in Kelvin, T0 = 298,15 K (25 °C), R0 = 10 kΩ und B = 3950. Bei Raumtemperatur ist die Empfindlichkeit sehr hoch: Nach der Formel B/T² ändert sich der Widerstand um etwa 4,4 % pro Grad. Deshalb liegt ein NTC mit 1 % Toleranz bei 25 °C nur etwa ±0,25 °C daneben; zu den Bereichsgrenzen hin kommt aber die Toleranz des B-Werts hinzu, und der Fehler wächst. Für mehr Genauigkeit über einen großen Bereich nutzt man die Steinhart-Hart-Gleichung mit drei Stützpunkten; Details im Artikel NTC-Thermistor.

1const int NTC_PIN = A1;          // bölücünün orta noktası / divider midpoint
2const float R_FIXED = 10000.0;   // 5V ile A1 arasındaki direnç / resistor between 5V and A1
3const float R0 = 10000.0;        // NTC'nin 25 °C'deki direnci / NTC resistance at 25 °C
4const float BETA = 3950.0;       // B katsayısı (veri sayfası) / B coefficient (datasheet)
5const float T0 = 298.15;         // 25 °C Kelvin cinsinden / 25 °C in kelvin
6const int SAMPLES = 16;          // ortalama için ölçüm sayısı / samples to average
7
8void setup() {
9  Serial.begin(9600);
10}
11
12void loop() {
13  long sum = 0;
14  for (int i = 0; i < SAMPLES; i++) {
15    sum += analogRead(NTC_PIN);
16    delay(2);
17  }
18  float adc = sum / (float)SAMPLES;
19
20  if (adc < 1.0 || adc > 1022.0) {                    // kopuk ya da kısa devre / open or shorted
21    Serial.println(F("NTC baglantisini kontrol et / Check the NTC wiring"));
22    delay(1000);
23    return;
24  }
25
26  float r = R_FIXED * adc / (1023.0 - adc);           // NTC direnci (ohm) / NTC resistance (ohm)
27  float invT = 1.0 / T0 + log(r / R0) / BETA;         // Beta denklemi / Beta equation
28  float tempC = 1.0 / invT - 273.15;                  // Kelvin -> °C
29
30  Serial.print(F("R: "));
31  Serial.print(r, 0);
32  Serial.print(F(" ohm  Sicaklik / Temp: "));
33  Serial.print(tempC, 1);
34  Serial.println(F(" C"));
35  delay(1000);
36}

In dieser Schaltung liegt der 10-kΩ-Festwiderstand zwischen 5V und A1, der NTC zwischen A1 und GND. Steigt die Temperatur, sinken der Widerstand des NTC und damit die Spannung an A1. Der Code berechnet aus dem Rohwert zuerst den Widerstand des NTC, dann mit der Beta-Gleichung die Temperatur in Kelvin und rechnet sie in Celsius um; der Mittelwert aus 16 Messungen senkt das ADC-Rauschen auf ein Viertel. Bei Raumtemperatur entspricht ein ADC-Schritt am Uno etwa 0,09 °C, die Auflösung ist also fünfmal besser als beim LM35 mit 5-V-Referenz. Bei fertigen NTC-Modulen (zum Beispiel KY-013) ist je nach Platine unterschiedlich, auf welcher Seite der Festwiderstand sitzt; sinkt der Messwert, wenn du den NTC mit etwas Warmem berührst, dreh die Widerstandsformel um: r = R_FIXED × (1023 − adc) / adc.

BME280: Temperatur, Luftfeuchtigkeit und Luftdruck in einem Modul

Der BME280 von Bosch misst Temperatur, relative Luftfeuchtigkeit und Luftdruck auf einem nur 2,5 × 2,5 mm großen Chip und kommuniziert über I2C (Adresse 0x76 oder 0x77) oder SPI. Bei der Temperatur bietet er 0,01 °C Auflösung sowie ±0,5 °C Genauigkeit bei 25 °C und ±1 °C zwischen 0 und 65 °C; er schafft Dutzende Messungen pro Sekunde und braucht im Schlafmodus weit unter 1 µA. Damit ist er ideal für batteriebetriebene Wetterstationen. Der Chip selbst verträgt nicht mehr als 3,6 V: Die lila Module mit 6 Pins sind meist nur für 3,3 V gedacht, Module mit 4 Pins und Spannungsregler dürfen an 5 V. Misst er dauerhaft, erwärmt sich der Chip leicht und zeigt einige Zehntelgrad zu viel an; für Wettermessungen genügt der Forced Mode mit ein paar Messungen pro Minute. Wie der I2C-Bus funktioniert, erklären wir in Was ist I2C?.

MAX6675 und Thermoelement Typ K: bis 1000 °C

Ein Thermoelement besteht aus zwei Drähten aus unterschiedlichen Metallen, die an einem Ende verschweißt sind. Der Temperaturunterschied zwischen der Schweißstelle (Messstelle) und dem Punkt, an dem die Drähte am Gerät angeschlossen sind (Vergleichsstelle), erzeugt eine winzige Spannung; beim Typ K sind das etwa 41 µV pro Grad. So eine kleine Spannung kann der ADC des Arduino nicht lesen, und außerdem musst du die Temperatur der Vergleichsstelle kennen. Der MAX6675 erledigt beides: Er verstärkt die Thermospannung, führt durch Messung seiner eigenen Temperatur die Vergleichsstellenkompensation durch und liefert das Ergebnis über SPI mit 12 Bit und 0,25 °C Auflösung. Sein Messbereich reicht von 0 bis +1023,75 °C; damit ist er hier die einzige Wahl für Orte, an denen die anderen Sensoren nicht überleben, etwa Lötkolben, Pizzaofen, Grill, Brennofen oder Auspuff.

Kenne auch die Grenzen des MAX6675: Unter 0 °C misst er nicht; der Wandler selbst hat zwischen 0 und 700 °C einen Fehler von etwa ±2 °C, dazu kommen bis zu ±3 °C Fehler der Vergleichsstellenkompensation und die Toleranz des Thermoelementdrahts. Rechne insgesamt also mit einer Genauigkeit von einigen Grad; in einem 800 °C heißen Ofen spielt das keine Rolle. Eine Wandlung dauert 0,17–0,22 Sekunden, warte zwischen zwei Messungen also mindestens 250 ms. Brauchst du auch Minustemperaturen, ist der neuere MAX31855 (−200 bis +1350 °C, 14 Bit) die bessere Wahl. Wie der SPI-Bus funktioniert, liest du in Was ist SPI?. Installiere in der Arduino IDE über den Bibliotheksverwalter die MAX6675 library von Adafruit und lade dann diesen Code hoch:

1#include "max6675.h"
2
3const int thermoDO  = 4;    // SO: veri çıkışı / data out
4const int thermoCS  = 5;    // CS: çip seçimi / chip select
5const int thermoCLK = 6;    // SCK: saat / clock
6
7MAX6675 thermocouple(thermoCLK, thermoCS, thermoDO);
8
9void setup() {
10  Serial.begin(9600);
11  delay(500);                                   // ilk ölçümü bekle / wait for the first conversion
12}
13
14void loop() {
15  float c = thermocouple.readCelsius();
16  if (isnan(c)) {                               // D2 biti: termokupl açık / bit D2: thermocouple open
17    Serial.println(F("Termokupl takili degil / Thermocouple not connected"));
18  } else {
19    Serial.print(F("Sicaklik / Temp: "));
20    Serial.print(c, 2);
21    Serial.println(F(" C"));
22  }
23  delay(500);                                   // en az 250 ms bekle / wait at least 250 ms
24}

MLX90614: Temperatur berührungslos messen

Der MLX90614 ist ein berührungsloser Temperatursensor, der die von Objekten abgegebene Infrarotstrahlung mit einer Thermosäule erfasst. Er liefert gleichzeitig zwei Werte: die Umgebungstemperatur, also die Temperatur seines eigenen Gehäuses (−40 bis +125 °C), und die Objekttemperatur der Oberfläche, auf die er gerichtet ist (−70 bis +380 °C). Um Raumtemperatur bietet er ±0,5 °C Genauigkeit und 0,02 °C Auflösung; er ist ab Werk kalibriert, kommuniziert über I2C (SMBus) unter der Adresse 0x5A, und der Bustakt darf höchstens 100 kHz betragen. Ideal ist er, um einen drehenden Motor, ein Lager, einen heißen Chip auf der Platine oder eine Pfanne auf dem Herd zu messen, ohne sie zu berühren.

Beim berührungslosen Messen gibt es zwei Kniffe. Der erste ist das Sichtfeld: Der Sensor misst den Mittelwert von allem, was in seinem Sichtkegel liegt. Die häufigste Version, der MLX90614ESF-BAA, hat ein Sichtfeld von 90°; in 5 cm Abstand mittelt er also über eine Fläche von etwa 10 cm Durchmesser. Für kleine Objekte bringst du den Sensor näher heran oder wählst eine Version mit engem Winkel wie 35° (BCC) oder 5° (BCI). Der zweite ist der Emissionsgrad: Ab Werk ist der Sensor auf 1,0 eingestellt. Für matten Lack, Kunststoff, Holz, Haut und Wasser liegt dieser Wert zwischen 0,9 und 0,98, das Ergebnis stimmt also nahezu; glänzende Metalloberflächen strahlen dagegen sehr wenig ab und wirken viel kälter, als sie sind. Ein Stück mattschwarzes Klebeband darauf ist eine einfache und wirksame Lösung. Installiere über den Bibliotheksverwalter die Bibliothek Adafruit MLX90614 und probiere diesen Code aus:

1#include <Wire.h>
2#include <Adafruit_MLX90614.h>
3
4Adafruit_MLX90614 mlx = Adafruit_MLX90614();
5
6void setup() {
7  Serial.begin(9600);
8  if (!mlx.begin()) {                           // varsayılan adres 0x5A / default address 0x5A
9    Serial.println(F("MLX90614 bulunamadi / not found"));
10    while (true) delay(10);
11  }
12  Serial.print(F("Emisivite / Emissivity: "));
13  Serial.println(mlx.readEmissivity(), 2);      // fabrika ayarı 1.00 / factory default 1.00
14}
15
16void loop() {
17  Serial.print(F("Ortam / Ambient: "));
18  Serial.print(mlx.readAmbientTempC(), 2);      // sensör gövdesi / sensor body
19  Serial.print(F(" C   Nesne / Object: "));
20  Serial.print(mlx.readObjectTempC(), 2);       // baktığı yüzey / surface in view
21  Serial.println(F(" C"));
22  delay(500);
23}

Anschlussübersicht: Arduino Uno, ESP32 und Raspberry Pi Pico

ESP32 und Pico arbeiten mit 3,3 V; versorgst du den NTC-Teiler aus 3V3, kann keine unzulässige Spannung an den ADC-Eingang gelangen. Schließe analoge Sensoren am ESP32 nur an ADC1-Pins (GPIO 32–39) an, denn die ADC2-Pins funktionieren bei eingeschaltetem WLAN nicht; für bidirektionale Datenleitungen wie beim DHT und DS18B20 meidest du dagegen GPIO 34–39, weil diese Pins nur Eingänge sind. BME280 (0x76) und MLX90614 (0x5A) haben unterschiedliche Adressen und können sich problemlos dieselben zwei I2C-Leitungen teilen. Alle Pins deines Boards findest du im Pinout-Tool, die Farbcodes der Pull-up-Widerstände im Widerstands-Farbcode-Rechner.

Vergleichstest mit dem ESP32: drei Sensoren am selben Ort

Die Unterschiede zwischen Sensoren siehst du am besten mit eigenen Augen. Der folgende ESP32-Code liest gleichzeitig einen DS18B20, einen DHT22 und einen BME280 aus und zeigt die Ergebnisse im seriellen Plotter der Arduino IDE als drei getrennte Linien. Setze die Sensoren nebeneinander aufs Breadboard, mindestens 10 cm vom ESP32 entfernt; der ESP32 erwärmt sich im Betrieb und beeinflusst jeden Sensor in seiner Nähe. Der Code benötigt die Bibliotheken OneWire, DallasTemperature, DHT sensor library und Adafruit BME280.

1#include <OneWire.h>
2#include <DallasTemperature.h>
3#include <DHT.h>
4#include <Wire.h>
5#include <Adafruit_Sensor.h>
6#include <Adafruit_BME280.h>
7
8const int ONE_WIRE_PIN = 4;     // DS18B20 DQ (4,7 kΩ pull-up -> 3V3)
9const int DHT_PIN = 27;         // DHT22 DATA
10
11OneWire oneWire(ONE_WIRE_PIN);
12DallasTemperature ds(&oneWire);
13DHT dht(DHT_PIN, DHT22);
14Adafruit_BME280 bme;            // I2C: SDA GPIO 21, SCL GPIO 22
15bool bmeOk = false;
16
17void setup() {
18  Serial.begin(115200);
19  ds.begin();
20  dht.begin();
21  bmeOk = bme.begin(0x76) || bme.begin(0x77);   // iki adresi de dene / try both addresses
22  if (!bmeOk) Serial.println("BME280 bulunamadi / not found");
23}
24
25void loop() {
26  ds.requestTemperatures();                     // 12 bitte ~750 ms sürer / takes ~750 ms at 12-bit
27  float tDs  = ds.getTempCByIndex(0);           // sensör yoksa -127 / -127 if missing
28  float tDht = dht.readTemperature();           // hata olursa NAN / NAN on error
29  float tBme = bmeOk ? bme.readTemperature() : NAN;
30
31  // Seri Çizici için etiket:değer biçimi / label:value format for the Serial Plotter
32  Serial.printf("DS18B20:%.2f,DHT22:%.1f,BME280:%.2f\n", tDs, tDht, tBme);
33  delay(2000);                                  // DHT22 en fazla 2 sn'de bir / DHT22 at most every 2 s
34}

Warte zuerst ein paar Minuten und sieh dir an, wie weit die Linien auseinanderliegen: Abweichungen von 0,5–1 °C liegen innerhalb der Genauigkeitsgrenzen dieser Sensoren. Stell dann ein Glas warmes Wasser daneben oder puste sanft auf alle drei. DS18B20 und BME280 reagieren innerhalb weniger Sekunden, die Linie des DHT22 hinkt wegen seines Kunststoffgitters deutlich hinterher. Liegt der BME280 dauerhaft einige Zehntelgrad über den anderen, ist das die Eigenerwärmung des Chips. Dieses kleine Experiment zeigt dir Unterschiede, die in keinem Datenblatt stehen. Um Messwerte über längere Zeit aufzuzeichnen, kannst du ein SD-Kartenmodul verwenden oder die Daten an Google Sheets schicken.

Temperatur messen mit dem Raspberry Pi Pico und MicroPython

Die MicroPython-Firmware des Pico bringt die Module dht, onewire und ds18x20 bereits mit; für DHT und DS18B20 musst du also keine zusätzlichen Dateien auf den Pico kopieren. Außerdem hat der RP2040-Chip einen internen Temperatursensor am Kanal 4 des ADC. Der folgende Code liest alle drei zusammen aus:

1from machine import Pin, ADC
2import dht, onewire, ds18x20, time
3
4dht22 = dht.DHT22(Pin(15))                          # DHT22 DATA -> GP15
5ds = ds18x20.DS18X20(onewire.OneWire(Pin(22)))      # DS18B20 DQ -> GP22 (4,7 kΩ pull-up)
6roms = ds.scan()                                    # hattaki sensörler / sensors on the bus
7cpu = ADC(4)                                        # RP2040 dahili sensörü / internal sensor
8
9def cpu_temp():
10    v = cpu.read_u16() * 3.3 / 65535                # ham değer -> volt / raw value -> volts
11    return 27 - (v - 0.706) / 0.001721              # RP2040 veri sayfası formülü / datasheet formula
12
13while True:
14    t_ds = None
15    if roms:
16        ds.convert_temp()                           # ölçümü başlat / start conversion
17        time.sleep_ms(750)                          # 12 bit dönüşüm süresi / 12-bit conversion time
18        t_ds = round(ds.read_temp(roms[0]), 2)
19    try:
20        dht22.measure()
21        t_dht, nem = dht22.temperature(), dht22.humidity()
22    except OSError:                                 # okuma hatası / read error
23        t_dht = nem = None
24    print("DS18B20:", t_ds, "DHT22:", t_dht, "Nem / RH:", nem,
25          "Pico:", round(cpu_temp(), 1))
26    time.sleep(2)

Der interne Sensor misst die Temperatur des Chips, nicht die des Raums, und kleine Abweichungen der ADC-Referenz können das Ergebnis um einige Grad verschieben. Er eignet sich daher nicht zur Umgebungsmessung, wohl aber, um zu prüfen, ob das Board überhitzt. Vergiss den 4,7-kΩ-Pull-up an der Datenleitung des DS18B20 nicht; die internen Pull-ups des Pico sind für 1-Wire zu schwach. Bist du neu beim Pico, fang mit Was ist der Raspberry Pi Pico? an.

Welcher Temperatursensor für welches Projekt?

Projektideen mit Temperatursensoren

• Smartes Gewächshaus: Miss Lufttemperatur und Luftfeuchtigkeit mit einem DHT22 und die Bodentemperatur mit einem DS18B20-Fühler; steuere Lüfter und Bewässerung mit einem Relaismodul. Das komplette Projekt findest du unter smartes Gewächshaus.
• Aquarienheizung mit Thermostat: Halte das Wasser mit einem wasserdichten DS18B20 zwischen 25 und 26 °C; nutze 0,5 °C Hysterese, damit das Relais nicht bei jeder kleinen Änderung schaltet.
• Batteriebetriebene Wetterstation: Kombiniere einen BME280 mit dem Deep-Sleep-Modus des ESP32 und miss alle zehn Minuten, damit das System monatelang mit Batterien läuft.
• Pizzaofen- oder Grillthermometer: Zeige die Ofentemperatur mit MAX6675 und Typ-K-Fühler in großen Ziffern auf einem OLED-Display an.
• Berührungsloser Motortemperaturalarm: Überwache mit einem MLX90614 die Oberflächentemperatur eines Motors oder eines 3D-Druckerbetts und lass einen Summer ertönen, wenn ein Grenzwert überschritten wird.
• Hausautomation: Schicke die Temperatur jedes Raums mit einem ESP32 per MQTT an Home Assistant und steuere die Heizung danach.
• Gefriertruhenwächter: Löse mit einem DS18B20 einen Alarm aus, wenn das Innere der Gefriertruhe über −12 °C steigt, und zeige den Wert auf einem I2C-LCD-Display an.

Häufige Fehler und ihre Lösungen

Kurz gesagt: DHT22 oder BME280 für Raum und Wetter, DS18B20 für Wasser und Kälte, LM35 oder NTC zum Lernen der Analogmessung und für schnelle Reaktion, MAX6675 für hohe Temperaturen und MLX90614 für Oberflächen, die du nicht berühren kannst, sind die richtigen Startpunkte. Wenn du auch andere Sensortypen kennenlernen möchtest, schau in den Ratgeber zu Arduino-Sensoren. In der BlueGrays-App findest du Projekte wie Temperatur- und Feuchtemessung mit dem DHT11, ein Thermometer mit NTC und LCD, eine Temperaturanzeige mit ESP32, DHT22 und LCD, einen ESP32-Temperaturlogger und eine smarte Bewässerung, jeweils mit Schaltplan und Code Schritt für Schritt.