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.
Cheap Yellow Display als Heizungs-Thermometer: DS18B20 Tauchfühler anschließen
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 😊
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.
Gerade wenn man:
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.
Temperatursensor DS18B20
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.
Das bedeutet konkret:
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.
Benötigte Komponenten
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.
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:
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 <DallasTemperature.h>
#define sensorPin 27
OneWire oneWire(sensorPin);
DallasTemperature ds(&oneWire);
const int MAX_SENSORS = 5;
DeviceAddress sensorAddrs[MAX_SENSORS];
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], i)) {
Serial.print("Sensor ");
Serial.print(i);
Serial.print(" Adresse: ");
for (uint8_t b = 0; b < 8; b++) {
if (sensorAddrs[i][b] < 16) Serial.print("0");
Serial.print(sensorAddrs[i][b], 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 <DallasTemperature.h>
#define sensorPin 27
OneWire oneWire(sensorPin);
DallasTemperature ds(&oneWire);
const int MAX_SENSORS = 5;
DeviceAddress sensorAddrs[MAX_SENSORS];
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], i)) {
Serial.print("Sensor ");
Serial.print(i);
Serial.print(" Adresse: ");
for (uint8_t b = 0; b < 8; b++) {
if (sensorAddrs[i][b] < 16) Serial.print("0");
Serial.print(sensorAddrs[i][b], 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], 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 <lvgl.h>
#include <TFT_eSPI.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#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[DRAW_BUF_SIZE / 4];
// 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[MAX_SENSORS];
// ---------------- UI ----------------
lv_obj_t *titleLabel;
lv_obj_t *sensorLabels[MAX_SENSORS];
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[i] != 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[i] = lv_label_create(scr);
lv_obj_set_style_text_color(sensorLabels[i], COLOR_WHITE, 0);
lv_obj_set_style_text_font(sensorLabels[i], &lv_font_montserrat_18, 0);
lv_obj_align(sensorLabels[i], LV_ALIGN_TOP_LEFT, 0, 50 + i * 30);
lv_label_set_text_fmt(sensorLabels[i], "Sensor %d: --.- \xC2\xB0C", 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.
ds.setResolution(11);
Serial.println("Suche nach DS18B20 Sensoren...");
Serial.print("Anzahl gefundener Sensoren: ");
Serial.println(ds.getDeviceCount());
for (int i = 0; i < MAX_SENSORS; i++) {
if (ds.getAddress(sensorAddrs[i], i)) {
Serial.print("Sensor ");
Serial.print(i + 1);
Serial.print(" Adresse: ");
for (uint8_t b = 0; b < 8; b++) {
if (sensorAddrs[i][b] < 16) Serial.print("0");
Serial.print(sensorAddrs[i][b], HEX);
}
Serial.println();
} else {
memset(sensorAddrs[i], 0, sizeof(DeviceAddress));
Serial.print("Sensor ");
Serial.print(i + 1);
Serial.println(" wurde nicht gefunden!");
}
}
}
void updateDashboard() {
ds.requestTemperatures();
for (int i = 0; i < MAX_SENSORS; i++) {
if (!isValidAddress(sensorAddrs[i])) {
lv_label_set_text_fmt(sensorLabels[i], "Sensor %d: (nicht belegt)", i + 1);
continue;
}
float tempC = ds.getTempC(sensorAddrs[i]);
// DallasTemperature: -127 = disconnected / Fehler
if (tempC < -100.0f || tempC > 150.0f) {
lv_label_set_text_fmt(sensorLabels[i], "Sensor %d: Fehler", i + 1);
} else {
lv_label_set_text_fmt(sensorLabels[i], "Sensor %d: %.1f °C", i + 1, tempC);
Serial.print("Sensor" + String(i + 1, DEC)+":");
Serial.println(tempC);
}
}
}
void setup() {
Serial.begin(9600);
delay(50);
setupLVGL();
setupSensors();
// Erste Anzeige sofort aktualisieren
updateDashboard();
firstUpdateDone = true;
}
void loop() {
// exakt wie dein Beispiel
lv_tick_inc(5);
lv_timer_handler();
unsigned long currentMillis = millis();
if (!firstUpdateDone || currentMillis > (lastRead + PAUSE)) {
lastRead = currentMillis;
updateDashboard(); // UI + Serial optional
// Optional: Debug-Ausgabe
// Serial.println("Dashboard aktualisiert");
}
delay(5);
}
Fazit & Ausblick
Mit dem Cheap Yellow Display und dem DS18B20 lässt sich mit überschaubarem Aufwand ein kompaktes Heizungs-Thermometer realisieren. Dank des 1-Wire-Protokolls können mehrere Sensoren über nur einen GPIO betrieben werden – ein klarer Vorteil bei der begrenzten Pin-Anzahl des CYD.
Das Dashboard auf dem Display ermöglicht eine direkte Kontrolle vor Ort – ohne zusätzliche Hardware oder komplexe Steuerungssysteme.
Ausblick
Im nächsten Beitrag erweitere ich das Projekt um eine Online-Komponente: Die gemessenen Temperaturen werden an ThingSpeak übertragen und dort automatisch gespeichert.
Damit erhältst du:
eine einfache Langzeitaufzeichnung
Diagramme zur Analyse
und die Möglichkeit, die Daten als CSV zu exportieren
So wird aus dem lokalen Heizungs-Display ein kleines Monitoring-System mit Verlaufsanalyse.
Ich zeige praxisnah, wie du Projekte mit Arduino, ESP32 und Smarthome-Komponenten umsetzt – Schritt für Schritt, mit Code und Schaltplänen.
2 thoughts on “Cheap Yellow Display als Heizungs-Thermometer: DS18B20 Tauchfühler anschließen”
Die meisten dieser Sensoren sind Fälschungen, und die laufen nicht immer mit 3,3V. Wenn es Probleme gibt dann braucht man noch einen Logic Level shifter. (Hat mich etwas Nerven gekostet)
Hi,
dann habe ich bisher immer Glück gehabt, die hier verwendeten Sensoren habe ich günstig bei Aliexpress geschossen und funktionieren am ESP32 (3.3V) sowie am Arduino (5V).
Hast du hier ggf. einen Link wo du „schlechte“ bekommen hast?
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional
Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt.Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
Die meisten dieser Sensoren sind Fälschungen, und die laufen nicht immer mit 3,3V. Wenn es Probleme gibt dann braucht man noch einen Logic Level shifter. (Hat mich etwas Nerven gekostet)
Hi,
dann habe ich bisher immer Glück gehabt, die hier verwendeten Sensoren habe ich günstig bei Aliexpress geschossen und funktionieren am ESP32 (3.3V) sowie am Arduino (5V).
Hast du hier ggf. einen Link wo du „schlechte“ bekommen hast?
Gruß, Stefan