Cheap Yellow Display als Heizungs-Thermometer: DS18B20 TauchfĂŒhler anschlieĂen
Das Cheap Yellow Display (ESP32-2432S028) ist weit mehr als nur ein gĂŒnstiges Touch-Display. Durch den integrierten ESP32 eignet es sich hervorragend fĂŒr kleine Monitoring-Projekte â zum Beispiel zur TemperaturĂŒberwachung einer Heizungsanlage.
https://youtu.be/-gNTzQVMN00
In diesem Beitrag zeige ich dir, wie du einen wasserdichten DS18B20 TauchfĂŒhler anschlieĂt und Temperaturen im Bereich von 0â90 °C zuverlĂ€ssig misst. Die aktuelle Temperatur wird direkt auf dem Display angezeigt.
Hinweis aus der Community
Die Idee zu diesem Beitrag stammt ĂŒbrigens direkt aus der YouTube-Community.
Unter meinem Video zum Thema âMehr als vier Taster am Cheap Yellow Display?â kam die Frage auf, ob sich mit dem Cheap Yellow Display auch ein TauchfĂŒhler zur HeizungsĂŒberwachung realisieren lĂ€sst.
Diese Frage greife ich hier auf und zeige eine mögliche Lösung mit dem DS18B20 â inklusive Anzeige auf dem Display und Logging ĂŒber ThingSpeak.
Genau solche Impulse aus der Community machen die Projekte hier besonders spannend đ
Problem & Ziel: Temperatur zuverlĂ€ssig ĂŒberwachen
In vielen Heizungsanlagen gibt es mehrere interessante Messpunkte:
Vorlauf, RĂŒcklauf, Pufferspeicher oder Warmwasserleitung. Zwar besitzen moderne Heizungen meist integrierte Sensoren, doch diese Werte sind nicht immer leicht zugĂ€nglich oder lassen sich nur umstĂ€ndlich auswerten.
- den Temperaturverlauf ĂŒber mehrere Tage analysieren möchte
- Optimierungspotenzial bei der Heizkurve sucht
- eine einfache visuelle Kontrolle direkt vor Ort wĂŒnscht
fehlt oft eine unkomplizierte und kostengĂŒnstige Lösung.
Genau hier setzt dieses Projekt an.
Ziel ist es, mit dem Cheap Yellow Display ein kompaktes Heizungs-Thermometer zu realisieren, das:
- die aktuelle Temperatur direkt auf dem Display anzeigt
- mehrere Sensoren ĂŒber nur einen GPIO unterstĂŒtzt
Ohne Spezialhardware, ohne teure Industrie-Controller â sondern mit einer einfachen, flexiblen ESP32-Lösung.
Warum DS18B20? Vorteile gegenĂŒber NTC & analogen FĂŒhlern
FĂŒr dieses Projekt verwende ich bewusst einen DS18B20 und keinen klassischen NTC-Widerstand oder analogen Temperatursensor.
Der gröĂte Vorteil liegt im verwendeten 1-Wire-Protokoll:
Der DS18B20 benötigt lediglich einen einzigen Daten-GPIO (zzgl. GND und 3,3 V) sowie einen 4,7 kΩ Pull-Up-Widerstand. Damit spart man wertvolle Pins.
Gerade beim Cheap Yellow Display (ESP32-2432S028) ist das ein echter Pluspunkt. Durch Display, Touch und interne Beschaltung stehen nur wenige GPIOs frei zur VerfĂŒgung â insgesamt sind es gerade einmal fĂŒnf gut nutzbare Pins.
Ein weiterer entscheidender Vorteil:
Jeder DS18B20 besitzt eine eindeutige 64-Bit-ID. Dadurch lassen sich mehrere Sensoren problemlos an denselben GPIO anschlieĂen und separat auslesen.
- Mehrere Temperaturmessstellen
- Nur ein Daten-Pin am ESP32
- Keine zusÀtzlichen ADC-KanÀle nötig
- Klare Adressierung jedes Sensors
Bei einem analogen NTC wÀre das deutlich aufwendiger:
Man benötigt fĂŒr jeden Sensor einen eigenen ADC-Eingang, eine passende Widerstandsbeschaltung und muss die Temperatur ĂŒber eine Kennlinie (z. B. Steinhart-Hart) berechnen.
Der DS18B20 hingegen liefert bereits einen digitalen, kalibrierten Temperaturwert mit einer Auflösung von bis zu 12 Bit â ohne Rechenaufwand auf deiner Seite.
Gerade fĂŒr ein Heizungs-Monitoring mit mehreren Messpunkten ist das die deutlich elegantere Lösung.
FĂŒr meinen Aufbau verwende ich folgende Bauteile:
- DS18B20 Temperatursensor* (wasserdicht, Edelstahlkapsel)
Ideal fĂŒr Heizungsleitungen oder Pufferspeicher. Der Sensor ist fĂŒr Temperaturen von -55 °C bis +125 °C ausgelegt und damit perfekt fĂŒr den Bereich 0â90 °C geeignet.
- 4,7 kΩ Widerstand*
Wird als Pull-Up-Widerstand fĂŒr die 1-Wire-Datenleitung benötigt. Ohne diesen funktioniert die Kommunikation mit dem DS18B20 nicht zuverlĂ€ssig.
- Breadboard*
FĂŒr den schnellen und sauberen Testaufbau ohne Löten.
- Breadboardkabel* (Dupont-Leitungen)
Zum Verbinden von Sensor, Widerstand und Cheap Yellow Display.
- Cheap Yellow Display (ESP32-2432S028)*
Das HerzstĂŒck des Projekts. Ăbernimmt das Auslesen des Sensors, die Anzeige der Temperatur sowie die Ăbertragung der Daten an ThingSpeak.
- Anschlusskabel Mini JST PH 1.25 (4-Pin)
Dieses Kabel wird benötigt, um die frei zugĂ€nglichen Pins des Cheap Yellow Displays zu nutzen. DarĂŒber greifen wir GND, 3,3 V und einen GPIO fĂŒr die 1-Wire-Datenleitung ab.
- USB-Anschlusskabel
Zur Stromversorgung des Displays sowie zum Programmieren ĂŒber die Arduino IDE bzw. fĂŒr die serielle Ausgabe.
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du ĂŒber diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beitrĂ€gt, diesen Blog zu unterstĂŒtzen. Der Preis fĂŒr dich bleibt dabei unverĂ€ndert. Vielen Dank fĂŒr deine UnterstĂŒtzung!
Pinbelegung des Temperatursensors DS18B20
Der kleine Sensor verfĂŒgt ĂŒber drei Beinchen welche mit GND, DATA und VDD belegt sind v.l.n.r. Die Richtung dabei ist wenn die flache Seite mit der Beschriftung zu dir zeigt.
Aufbau der Schaltung - DS18B20 Sensor am Cheap Yellow Display
FĂŒr den Anschluss eines DS18B20 Sensors benötigst du nur einen 4,7 kOhm Widerstand sowie in paar Breadboardkabel.
Wenn du nur einen Sensor anschlieĂe möchtest sieht die Schaltung wiefolgt aus:
Schaltung - ein DS18B20 Sensor am Cheap Yellow Display
Die Sensoren bekommst du entweder als einfachen Baustein oder auch in einem wasserfesten GehÀuse. Wenn du es besonders einfach haben möchtest dann bekommst du auch noch eine fertige Platine wo du den Sensor aufstecken kannst und so dir ein Anschluss auf dem Breadboard sparen kannst.
verschiedene DS18B20 Sensoren
Du kannst jedoch auch mehrere Sensoren an einen GPIO anschlieĂen und auslesen, da die Sensoren jeweils wie bereits erwĂ€hnt ĂŒber eine eindeutige UUID verfĂŒgen kann man daraus dann jeden Sensor eindeutig erkennen (dazu spĂ€ter im Abschnitt zum Quellcode mehr).
Schaltung - mehrere DS18B20 Sensoren am Cheap Yellow Display
Auslesen des Sensors am Mikrocontroller in der Arduino IDE
Auf meinem Blog habe ich dir bereits an diversen Mikrocontrollern gezeigt wie man den Sensor auslesen kann.
- DS18B20-Sensoren am Raspberry Pi Pico W: Temperaturdaten auf einer Webseite anzeigen
- ESP32 â Temperatursensor DS18B20
- Ausgeben der Temperaturwerte des DS18B20 Sensors auf dem M5StickC
- Weekendprojekt: Relais & Temperatursensor DS18B20 steuern
Die Programmierung unterscheidet sich hier nicht wirklich, jedoch möchte ich dir aufzeigen wie du die Sensordaten via LVGL auf dem Display des Cheap Yellow Display anzeigen lassen kannst. Dabei wird die Anzahl der Sensoren flexibel sein!
Schaltung - Cheap Yellow Display mit fĂŒnf Temperatursensoren vom Typ DS18B20
Hier das fertige Projekt zum Download als ZIP-Datei:
Programm: Ausgeben der Sensordaten von fĂŒnf DS18B20 Sensoren auf dem Cheap Yellow DisplayHerunterladen
Benötigte Bibliothek zum auslesen des Sensors in der Arduino IDE
Damit wir den Sensor auslesen können, mĂŒssen wir die Bibliothek "DallasTemperature" ĂŒber den Bibliotheksverwalter der Arduino IDE installieren. Du findest auf dem GitHub Repository von Miles Burton noch weitere Informationen und Beispiele zu dieser.
Auslesen der Adressen der angeschlossenen Sensoren
Wie bereits mehrfach erwĂ€hnt verfĂŒgt jeder Sensor ĂŒber eine eigene UUID bzw. Adresse ĂŒber welche dieser angesteuert / ausgelesen werden kann. In meinem Fall habe ich 5 Sensoren angeschlossen und lese mir zunĂ€chst einmal alle Adressen aus und speicher mir diese in einer Liste (ein Array).
Quellcode
#include
#define sensorPin 27
OneWire oneWire(sensorPin);
DallasTemperature ds(&oneWire);
const int MAX_SENSORS = 5;
DeviceAddress sensorAddrs;
void setup(void) {
Serial.begin(115200);
delay(10);
ds.begin();
Serial.println("Suche nach Sensoren...");
Serial.print("Anzahl gefundener Sensoren: ");
Serial.println(ds.getDeviceCount(), DEC);
for (int i = 0; i < MAX_SENSORS; i++) {
if (ds.getAddress(sensorAddrs, i)) {
Serial.print("Sensor ");
Serial.print(i);
Serial.print(" Adresse: ");
for (uint8_t b = 0; b < 8; b++) {
if (sensorAddrs < 16) Serial.print("0");
Serial.print(sensorAddrs, HEX);
}
Serial.println();
} else {
Serial.print("Sensor ");
Serial.print(i);
Serial.println(" wurde nicht gefunden!");
}
}
}
void loop(void) {
}
Die Ausgabe erfolgt beim starten / neustarten des Mikrocontrollers daher erfolgt zusÀtzlich noch eine technische Ausgabe im oberen Bereich!
Ausgabe der Adressen der angeschlossenen DS18B20 Sensoren ĂŒber seriellen Monitor
Ausgeben der Sensordaten der fĂŒnf angeschlossenen Sensoren im seriellen Plotter
Die Arduino IDE verfĂŒgt ĂŒber einen seriellen Plotter in welchem wir recht einfach einen und auch mehrere numerische Werte in einem Liniendiagramm visualisieren lassen können. Diesen möchten ich nun nutzen um die fĂŒnf Sensorwerte grafisch darzustellen.
Quellcode
#include
#define sensorPin 27
OneWire oneWire(sensorPin);
DallasTemperature ds(&oneWire);
const int MAX_SENSORS = 5;
DeviceAddress sensorAddrs;
void setup(void) {
Serial.begin(115200);
delay(10);
ds.begin();
Serial.println("Suche nach Sensoren...");
Serial.print("Anzahl gefundener Sensoren: ");
Serial.println(ds.getDeviceCount(), DEC);
for (int i = 0; i < MAX_SENSORS; i++) {
if (ds.getAddress(sensorAddrs, i)) {
Serial.print("Sensor ");
Serial.print(i);
Serial.print(" Adresse: ");
for (uint8_t b = 0; b < 8; b++) {
if (sensorAddrs < 16) Serial.print("0");
Serial.print(sensorAddrs, HEX);
}
Serial.println();
} else {
Serial.print("Sensor ");
Serial.print(i);
Serial.println(" wurde nicht gefunden!");
}
}
}
void printSensordata(DeviceAddress deviceAddress, int index) {
float tempC = ds.getTempC(deviceAddress);
Serial.print("Sensor" + String(index, DEC) + ":");
Serial.println(tempC);
}
void loop(void) {
ds.requestTemperatures();
for (int i = 0; i < MAX_SENSORS; i++) {
printSensordata(sensorAddrs, i+1);
}
delay(125);
}
Ausgeben der Sensordaten auf dem Display via LVGL
Nachdem wir die Sensordaten erfolgreich ermittelt und ĂŒber die serielle Schnittstelle ausgegeben haben, ist der nĂ€chste Schritt nicht mehr weit:
Die Temperaturwerte sollen direkt auf dem Display des Cheap Yellow Displays angezeigt werden.
Schaltung - Cheap Yellow Display mit fĂŒnf Temperatursensoren vom Typ DS18B20
Hier kommt erneut LVGL zum Einsatz.
Die Einrichtung der Bibliothek ist zu Beginn etwas aufwendiger â insbesondere was Display-Initialisierung und Buffer-Konfiguration betrifft. Ist das Setup jedoch einmal erledigt, lĂ€sst sich die BenutzeroberflĂ€che sehr strukturiert und vergleichsweise komfortabel programmieren.
Gerade fĂŒr ein kleines Heizungs-Dashboard bietet LVGL eine saubere Möglichkeit, Werte ĂŒbersichtlich darzustellen und das Layout flexibel anzupassen.
Quellcode
/*
================================================================
Titel: Cheap Yellow Display als Heizungs-Thermometer
Projekt: DS18B20 TauchfĂŒhler mit LVGL Dashboard
Autor: Stefan Draeger
Website: https://draeger-it.blog
Beitrag: https://draeger-it.blog/cheap-yellow-display-als-heizungs-thermometer-ds18b20-tauchfuehler-anschliessen/
Datum: Februar 2026
Plattform: Cheap Yellow Display (ESP32-2432S028)
================================================================
Beschreibung:
---------------------------------------------------------------
Dieses Projekt zeigt, wie ein oder mehrere DS18B20 Temperatur-
sensoren (wasserdichte TauchfĂŒhler) am Cheap Yellow Display
betrieben werden.
Funktionen:
- Auslesen von bis zu 5 DS18B20 Sensoren ĂŒber OneWire (GPIO 27)
- Eindeutige Adressierung ĂŒber 64-Bit Sensor-ID
- Temperaturmessung mit 11-Bit Auflösung
- Anzeige der Messwerte auf dem Display via LVGL
- Serielles Debugging ĂŒber USB
Ziel des Projekts ist es, ein kompaktes Heizungs-Thermometer
mit Live-Anzeige zu realisieren, das sich flexibel erweitern lÀsst
(z. B. Logging, Cloud-Anbindung, GrenzwertĂŒberwachung).
Hinweis:
FĂŒr die Anzeige wird LVGL in Kombination mit TFT_eSPI verwendet.
Die Display-Konfiguration muss zuvor korrekt eingerichtet sein.
Weitere Details und Erweiterungen findest du im Blogbeitrag.
---------------------------------------------------------------
*/
#include
#include
#include
#include
#define TFT_HOR_RES 240
#define TFT_VER_RES 320
#define TFT_ROTATION LV_DISPLAY_ROTATION_270
#define DRAW_BUF_SIZE (TFT_HOR_RES * TFT_VER_RES / 10 * (LV_COLOR_DEPTH / 8))
uint32_t draw_buf;
// Farben wie in deinem Beispiel
#define COLOR_BG lv_color_hex(0x000000)
#define COLOR_WHITE lv_color_hex(0xFFFFFF)
#define COLOR_YELLOW lv_color_hex(0xFDD835)
#define COLOR_GRAY lv_color_hex(0x9E9E9E)
// ---------------- DS18B20 ----------------
#define sensorPin 27
OneWire oneWire(sensorPin);
DallasTemperature ds(&oneWire);
const int MAX_SENSORS = 5;
DeviceAddress sensorAddrs;
// ---------------- UI ----------------
lv_obj_t *titleLabel;
lv_obj_t *sensorLabels;
unsigned long lastRead = 0;
const int PAUSE = 1000; // 1s Update ist praxisnah fĂŒr Heizung
bool firstUpdateDone = false;
bool isValidAddress(const DeviceAddress addr) {
for (uint8_t i = 0; i < 8; i++) {
if (addr != 0) return true;
}
return false;
}
void setupLVGL() {
lv_init();
lv_display_t *disp = lv_tft_espi_create(
TFT_HOR_RES,
TFT_VER_RES,
draw_buf,
sizeof(draw_buf));
lv_display_set_rotation(disp, TFT_ROTATION);
lv_obj_t *scr = lv_screen_active();
lv_obj_set_style_bg_color(scr, COLOR_BG, 0);
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, 0);
lv_obj_set_style_pad_all(scr, 12, 0);
lv_obj_set_scrollbar_mode(scr, LV_SCROLLBAR_MODE_OFF);
// Titel
titleLabel = lv_label_create(scr);
lv_label_set_text(titleLabel, "DS18B20 Sensoren");
lv_obj_set_style_text_color(titleLabel, COLOR_YELLOW, 0);
lv_obj_set_style_text_font(titleLabel, &lv_font_montserrat_28, 0);
lv_obj_align(titleLabel, LV_ALIGN_TOP_MID, 0, 0);
// Sensorzeilen
for (int i = 0; i < MAX_SENSORS; i++) {
sensorLabels = lv_label_create(scr);
lv_obj_set_style_text_color(sensorLabels, COLOR_WHITE, 0);
lv_obj_set_style_text_font(sensorLabels, &lv_font_montserrat_18, 0);
lv_obj_align(sensorLabels, LV_ALIGN_TOP_LEFT, 0, 50 + i * 30);
lv_label_set_text_fmt(sensorLabels, "Sensor %d: --.- xC2xB0C", i + 1);
}
// Kleiner Hinweis unten
lv_obj_t *hint = lv_label_create(scr);
lv_obj_set_style_text_color(hint, COLOR_GRAY, 0);
lv_obj_set_style_text_font(hint, &lv_font_montserrat_12, 0);
lv_label_set_text(hint, "Stefan Draeger - https://draeger-it.blog");
lv_obj_align(hint, LV_ALIGN_BOTTOM_MID, 0, 0);
}
void setupSensors() {
ds.begin();
// FĂŒr schnellere Messungen: 11-bit (~375ms). FĂŒr Heizung völlig ausreichend.
