Bauteile · 8 Min. Lesezeit

Cheap Yellow Display ESP32 (CYD): Pinbelegung, Setup, LVGL

Cheap Yellow Display mit ESP32 (ESP32-2432S028R): Pinbelegung, TFT_eSPI und XPT2046 einrichten, Touch kalibrieren, SD-Karte, Lautsprecher und LVGL.

Das Cheap Yellow Display mit ESP32 (kurz CYD), offiziell ESP32-2432S028R, ist ein fertiges Entwicklungsboard, das einen ESP32, einen 2,8-Zoll-Farb-Touchscreen, einen microSD-Slot, eine RGB-LED, einen Lichtsensor und einen Lautsprecherausgang auf einer einzigen gelben Platine vereint. Der Spitzname erklärt sich von selbst: Die Platine ist gelb, günstig und hat ein Display. Ein USB-Kabel anstecken, Sketch hochladen, und du hast eine Touch-Oberfläche, ohne zu löten oder auch nur ein einziges Jumperkabel zu stecken.

In diesem Artikel siehst du, was auf dem Board steckt, wie du die Versionen unterscheidest, und bekommst die komplette Pinbelegung. Danach richtest du in der Arduino IDE die Bibliotheken TFT_eSPI und XPT2046_Touchscreen ein, schreibst Text auf das Display, kalibrierst den Touch, schaltest die RGB-LED über Bildschirmtasten, speicherst Messwerte auf einer microSD-Karte und baust mit LVGL deine erste echte Oberfläche. Zum Schluss gibt es Projektideen wie eine Wetteranzeige und ein Smart-Home-Panel sowie Lösungen für die häufigsten Probleme.

2,8-Zoll-TFT-Displaymodul mit ILI9341-Treiber
Ein einzelnes ILI9341-TFT-Modul: Das 2,8-Zoll-Display des CYD nutzt denselben Treiber; der Unterschied ist, dass ESP32 und Touch-Schaltung auf derselben Platine sitzen.

Was ist das Cheap Yellow Display und was ist auf dem Board?

Herzstück ist ein ESP32-WROOM-32-Modul: Dual-Core-Prozessor mit bis zu 240 MHz, 520 KB SRAM, 4 MB Flash, 2,4-GHz-WLAN und Bluetooth. Alles, was du in Was ist der ESP32? gelernt hast, gilt also auch hier. Das Display hängt am HSPI-Bus des ESP32, der XPT2046-Chip für das resistive Touchpanel dagegen mit eigenen Pins am zweiten SPI-Bus (VSPI). Dieses Detail ist wichtig, denn allgemeine TFT-Beispiele gehen davon aus, dass Touch und Display denselben Bus teilen, und funktionieren auf dem CYD nicht. PSRAM gibt es keinen, deshalb wird das Bild nicht komplett im Speicher gehalten, sondern stückweise gezeichnet.

MerkmalWert
ProzessormodulESP32-WROOM-32 (Dual Core, 240 MHz)
Speicher520 KB SRAM, 4 MB Flash, kein PSRAM
Display2,8-Zoll-TFT, 240×320 Pixel, 16-Bit-Farbe (RGB565)
DisplaytreiberILI9341 (bei der Version mit zwei USB-Buchsen meist ST7789)
TouchResistives Panel, XPT2046-Controller
SpeicherkartemicroSD-Slot (SPI)
ExtrasRGB-LED, LDR-Lichtsensor, Lautsprecherausgang (SC8002B-Verstärker)
USB und VersorgungMicro-USB, CH340-USB-Seriell-Chip, 5 V
TasterBOOT (GPIO 0) und RST

Board-Versionen: Was bedeutet ESP32-2432S028R?

Der Modellname ist eine Kurzbeschreibung: 2432 steht für die Auflösung (240×320), S028 für die Displaygröße (2,8 Zoll) und das R am Ende für resistiven Touch. Zur selben Familie gehören Boards mit C am Ende (kapazitiver Touch) und N (ohne Touch). Da Händler alle als "Cheap Yellow Display" verkaufen, prüfe vor der Bestellung den genauen Modellnamen: Pinbelegung und Displaytreiber können sich von Version zu Version ändern.

BoardDisplayWoran erkennbarAchtung
ESP32-2432S028R (ein USB)2,8" 240×320, ILI9341Nur Micro-USB-BuchseDie Version, auf der die meisten Beispiele und dieser Artikel basieren
ESP32-2432S028R (zwei USB)2,8" 240×320, meist ST7789Micro-USB und USB-C nebeneinanderFarben können invertiert sein; Treiber oder invertDisplay anpassen
ESP32-2432S0242,4" 240×320Kleineres DisplayPins und Touch-Chip können abweichen
ESP32-2432S0323,2" 240×320Größeres BoardDie kapazitive Version liest Touch per I2C
ESP32-3248S0353,5" 320×480, ST7796Höhere AuflösungBraucht eine eigene TFT_eSPI-Konfiguration
Bei CYDs mit zwei USB-Buchsen (Micro-USB + USB-C) hat das Display meist einen ST7789-Treiber. Mit der ILI9341-Einstellung geht das Display zwar an, die Farben wirken aber wie ein Negativ: Weiß statt Schwarz, Gelb statt Blau. Wähle dann in der User_Setup.h ST7789_DRIVER oder füge direkt nach tft.init() tft.invertDisplay(1) ein.

CYD Pinbelegung

BauteilSignal und GPIOHinweis
Display (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2HSPI-Bus; RST hängt an EN
HintergrundbeleuchtungGPIO 21HIGH = an; per PWM dimmbar
Touch (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36VSPI-Bus, getrennt vom Display
microSDSCK 18, MISO 19, MOSI 23, CS 5Standard-VSPI-Pins
RGB-LEDRot 4, Grün 16, Blau 17Gemeinsame Anode: LOW = an
LDR-LichtsensorGPIO 34Nur Eingang, mit analogRead lesen
LautsprecherGPIO 26SC8002B-Verstärker, Stecker SPEAK
BOOT-TasterGPIO 0Im Sketch auch als Taster nutzbar
Serielle Schnittstelle (P1)TX 1, RX 3Geteilt mit dem USB-Seriell-Chip
Freie PinsGPIO 22, 27 (CN1), GPIO 35 (P3)35 ist nur Eingang

Die kleinen JST-Stecker (1,25 mm Raster) am Rand sind deine Verbindung zur Außenwelt. CN1 führt GND, GPIO 22, GPIO 27 und 3,3 V, ideal für einen I2C-Sensor: Mit Wire.begin(27, 22) kannst du zum Beispiel einen BME280 direkt anschließen. P3 bietet GPIO 35, 22 und 21, P1 den 5-V-Eingang und die seriellen Leitungen TX/RX. Um die Pins mit den allgemeinen Einschränkungen des ESP32 abzugleichen, nutze das Pinout-Tool.

GPIO 21 am Stecker P3 steuert gleichzeitig die Hintergrundbeleuchtung; schließt du dort etwas an und ziehst den Pin auf LOW, wird das Display dunkel. GPIO 35 funktioniert nur als Eingang und kann weder LED noch Relais treiben. Wenn du ein externes Bauteil über den 3,3-V-Pin an CN1 versorgst, zieh keine Hunderte Milliampere daraus; das Board braucht für Display und WLAN schon selbst einiges an Strom.

Arduino IDE einrichten: Board-Einstellungen und Bibliotheken

  1. Installiere das ESP32-Boardpaket in der Arduino IDE (esp32 by Espressif im Boardverwalter) und wähle ESP32 Dev Module als Board.
  2. Verbinde das Board per USB-Kabel. Erscheint kein Port, installiere den CH340-Treiber und achte darauf, dass dein Kabel Daten überträgt und nicht nur lädt.
  3. Installiere über den Bibliotheksverwalter TFT_eSPI (Bodmer) und XPT2046_Touchscreen (Paul Stoffregen).
  4. Ersetze den Inhalt der User_Setup.h im TFT_eSPI-Ordner durch die Einstellungen aus dem nächsten Abschnitt.
  5. Bricht der Upload mit "Failed to connect" ab, halte beim Start des Uploads die BOOT-Taste gedrückt; mehr dazu in ESP32 Failed to connect.

TFT_eSPI konfigurieren: User_Setup.h

TFT_eSPI ist eine sehr schnelle Bibliothek, und diese Geschwindigkeit kommt von Pin-Einstellungen, die beim Kompilieren feststehen. Sie stehen in der Datei User_Setup.h im Bibliotheksordner (Dokumente > Arduino > libraries > TFT_eSPI). Sichere die Datei, lösche ihren Inhalt und füge die folgenden Zeilen ein. Bei einem Update der Bibliothek wird die Datei auf den Standard zurückgesetzt; bewahre deine Version also separat auf und kopiere sie nach jedem Update zurück.

C++ (Arduino IDE)
1// TFT_eSPI/User_Setup.h: CYD (ESP32-2432S028R) ayarı / setup for the CYD
2#define ILI9341_2_DRIVER       // iki USB'li kartta ST7789_DRIVER / two-USB board: ST7789_DRIVER
3#define TFT_WIDTH  240
4#define TFT_HEIGHT 320
5#define TFT_BL   21            // arka ışık / backlight
6#define TFT_BACKLIGHT_ON HIGH
7#define TFT_MISO 12
8#define TFT_MOSI 13
9#define TFT_SCLK 14
10#define TFT_CS   15
11#define TFT_DC    2
12#define TFT_RST  -1            // EN'e bağlı / tied to EN
13#define USE_HSPI_PORT          // ekran HSPI hattında / display on the HSPI bus
14
15#define LOAD_GLCD
16#define LOAD_FONT2
17#define LOAD_FONT4
18#define LOAD_FONT6
19#define LOAD_FONT7
20#define LOAD_FONT8
21#define LOAD_GFXFF
22#define SMOOTH_FONT
23
24#define SPI_FREQUENCY       55000000   // sorun olursa 27000000 / use 27000000 if unstable
25#define SPI_READ_FREQUENCY  20000000
26#define SPI_TOUCH_FREQUENCY  2500000

Erster Test: Text auf dem Display und Zeichnen per Touch

C++ (Arduino IDE)
1#include <SPI.h>
2#include <TFT_eSPI.h>
3#include <XPT2046_Touchscreen.h>
4
5// Dokunmatik (XPT2046) kendi SPI hattında / touch (XPT2046) on its own SPI bus
6#define XPT2046_IRQ  36
7#define XPT2046_MOSI 32
8#define XPT2046_MISO 39
9#define XPT2046_CLK  25
10#define XPT2046_CS   33
11
12SPIClass touchSpi(VSPI);
13XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
14TFT_eSPI tft;
15
16void setup() {
17  Serial.begin(115200);
18  touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
19  ts.begin(touchSpi);
20  ts.setRotation(1);               // ekranla aynı yön / same orientation as the screen
21
22  tft.init();
23  tft.setRotation(1);              // yatay 320x240 / landscape 320x240
24  tft.fillScreen(TFT_BLACK);
25  tft.setTextColor(TFT_WHITE, TFT_BLACK);
26  tft.drawCentreString("BlueGrays CYD", 160, 10, 4);
27  tft.drawCentreString("Ekrana dokun / Touch the screen", 160, 40, 2);
28}
29
30void loop() {
31  if (ts.tirqTouched() && ts.touched()) {
32    TS_Point p = ts.getPoint();
33    // Ham değerleri piksele çevir / convert raw values to pixels
34    int x = map(p.x, 200, 3700, 0, 319);
35    int y = map(p.y, 240, 3800, 0, 239);
36    x = constrain(x, 0, 319);
37    y = constrain(y, 0, 239);
38    tft.fillCircle(x, y, 3, TFT_YELLOW);
39    Serial.printf("ham/raw x=%d y=%d z=%d -> piksel/pixel %d,%d\n", p.x, p.y, p.z, x, y);
40  }
41}

Die wichtigste Zeile ist SPIClass touchSpi(VSPI): Sie hängt den Touch-Controller unabhängig vom Display mit eigenen Pins an den zweiten SPI-Bus. ts.setRotation(1) und tft.setRotation(1) müssen denselben Wert haben; sonst passen die berührte Stelle und der gezeichnete Punkt nicht zusammen. Im Querformat reichen die Koordinaten von 0 bis 319 für x und von 0 bis 239 für y. Probiere nach dem Hochladen, mit einem Stift auf das Display zu schreiben; folgen die Linien deiner Hand, sind Display und Touch richtig eingestellt.

Touch kalibrieren (XPT2046)

Der XPT2046 liefert keine Pixel, sondern Rohwerte zwischen 0 und 4095. Die Zahlen 200, 3700 und 240, 3800 im Code sind der Teil dieses Rohbereichs, der zu den Displayrändern passt, und sie unterscheiden sich von Board zu Board leicht. Zum Kalibrieren öffnest du den seriellen Monitor mit 115200 Baud, tippst mit einem Stift nacheinander auf die vier Ecken und notierst die kleinsten und größten Roh-x- und Roh-y-Werte. Trägst du diese vier Zahlen in die map()-Zeilen ein, schrumpft der Versatz zwischen Berührung und Punkt auf wenige Pixel. Das resistive Panel misst auch den Druck: touched() liefert nur bei ausreichend festem Druck true, doch wenn du an den Rändern zitternde Werte siehst, kannst du für p.z eine höhere Schwelle setzen.

RGB-LED, LDR und Lautsprecher: ein Touch-Bedienfeld

RGB-LED, LDR und Lautsprecherausgang auf der Rückseite reichen für dein erstes Projekt. Der folgende Code zeichnet drei große Tasten; tippst du eine an, schaltet sie die jeweilige LED-Farbe um und der Lautsprecher gibt einen kurzen Klick aus. Der gelbe Balken unten zeigt den Wert des Lichtsensors und wird jede halbe Sekunde aktualisiert.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <TFT_eSPI.h>
3#include <XPT2046_Touchscreen.h>
4
5#define XPT2046_IRQ  36
6#define XPT2046_MOSI 32
7#define XPT2046_MISO 39
8#define XPT2046_CLK  25
9#define XPT2046_CS   33
10
11const int LED_PINS[3] = {4, 16, 17};   // RGB LED: kırmızı, yeşil, mavi (LOW = yanar) / red, green, blue (LOW = on)
12const int LDR_PIN = 34;                // ışık sensörü / light sensor
13const int SPEAKER_PIN = 26;            // hoparlör yükselticisi / speaker amplifier
14const char* NAMES[3] = {"RED", "GREEN", "BLUE"};
15const uint16_t COLORS[3] = {TFT_RED, TFT_GREEN, TFT_BLUE};
16
17SPIClass touchSpi(VSPI);
18XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
19TFT_eSPI tft;
20
21bool ledOn[3] = {false, false, false};
22bool wasTouched = false;
23unsigned long lastLdr = 0;
24
25void drawButton(int i) {
26  int x = 8 + i * 104;                                  // 3 düğme yan yana / 3 buttons side by side
27  tft.fillRoundRect(x, 60, 96, 80, 10, ledOn[i] ? COLORS[i] : TFT_DARKGREY);
28  tft.setTextColor(TFT_WHITE);
29  tft.drawCentreString(NAMES[i], x + 48, 92, 2);
30}
31
32void setup() {
33  for (int i = 0; i < 3; i++) {
34    pinMode(LED_PINS[i], OUTPUT);
35    digitalWrite(LED_PINS[i], HIGH);                    // HIGH = sönük / HIGH = off
36  }
37  touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
38  ts.begin(touchSpi);
39  ts.setRotation(1);
40  tft.init();
41  tft.setRotation(1);
42  tft.fillScreen(TFT_BLACK);
43  tft.setTextColor(TFT_WHITE, TFT_BLACK);
44  tft.drawString("BlueGrays panel", 8, 12, 4);
45  for (int i = 0; i < 3; i++) drawButton(i);
46}
47
48void loop() {
49  bool touchedNow = ts.tirqTouched() && ts.touched();
50  if (touchedNow && !wasTouched) {                      // yalnız ilk dokunuşta / only on the first touch
51    TS_Point p = ts.getPoint();
52    int x = map(p.x, 200, 3700, 0, 319);
53    int y = map(p.y, 240, 3800, 0, 239);
54    if (y > 60 && y < 140) {
55      int i = constrain((x - 8) / 104, 0, 2);
56      ledOn[i] = !ledOn[i];
57      digitalWrite(LED_PINS[i], ledOn[i] ? LOW : HIGH);
58      drawButton(i);
59      tone(SPEAKER_PIN, 2000, 30);                      // kısa tık sesi / short click sound
60    }
61  }
62  wasTouched = touchedNow;
63
64  if (millis() - lastLdr > 500) {                       // yarım saniyede bir / every half second
65    lastLdr = millis();
66    int light = analogRead(LDR_PIN);                    // 0-4095
67    tft.fillRect(8, 170, 304, 20, TFT_BLACK);
68    tft.fillRect(8, 170, map(light, 0, 4095, 0, 304), 20, TFT_YELLOW);
69    tft.setTextColor(TFT_WHITE, TFT_BLACK);
70    tft.drawString("LDR: " + String(light) + "    ", 8, 200, 2);
71  }
72}

Weil die RGB-LED mit gemeinsamer Anode verdrahtet ist, ist die Logik umgekehrt: LOW schaltet eine Farbe ein, HIGH aus; deshalb setzt setup() zuerst alle drei Pins auf HIGH. Die Variable wasTouched verhindert, dass eine Taste ständig umschaltet, solange dein Finger auf dem Display bleibt; nur der Beginn der Berührung zählt. Der LDR-Wert bewegt sich wegen des Spannungsteiler-Widerstands auf dem Board eventuell nur in einem schmalen Bereich; miss in deinem Raum die Werte für dunkel und hell und lege die Schwelle danach fest. Am Lautsprecheranschluss kannst du einen kleinen 8-Ω-Lautsprecher betreiben und mit tone() Pieptöne und einfache Melodien abspielen.

Daten auf der microSD-Karte speichern

Der Kartenslot hängt an den Standard-VSPI-Pins des ESP32 (18, 19, 23 und 5 für CS), daher genügt SD.begin(5). Formatiere die Karte mit FAT32; Karten bis 32 GB laufen problemlos. Das Beispiel unten hängt alle fünf Sekunden die Zeit und die Helligkeit an die Datei log.csv an, die du später in jeder Tabellenkalkulation öffnen kannst. Allgemeines zu SD-Karten findest du im Artikel SD-Kartenmodul.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <SD.h>
3
4const int SD_CS = 5;          // microSD: SCK 18, MISO 19, MOSI 23, CS 5
5const int LDR_PIN = 34;
6
7void setup() {
8  Serial.begin(115200);
9  if (!SD.begin(SD_CS)) {     // varsayılan SPI pinleri / default SPI pins
10    Serial.println("SD kart yok / no SD card");
11    return;
12  }
13  Serial.printf("SD: %llu MB\n", SD.cardSize() / (1024 * 1024));
14}
15
16void loop() {
17  File f = SD.open("/log.csv", FILE_APPEND);   // dosyanın sonuna ekle / append to the file
18  if (f) {
19    f.printf("%lu,%d\n", millis() / 1000, analogRead(LDR_PIN));
20    f.close();
21  }
22  delay(5000);
23}
Touch-Controller und SD-Karte nutzen beide die VSPI-Hardware, aber mit unterschiedlichen Pins. Brauchst du beides in einem Sketch, nimm eine Bibliothek, die den Touch per Software-SPI liest (zum Beispiel XPT2046_Bitbang), oder starte den SPI-Bus vor und nach jedem SD-Zugriff mit den passenden Pins neu. Sonst verstummt das eine, während das andere arbeitet.

Die erste Oberfläche mit LVGL

Tasten, Schieberegler und Diagramme einzeln mit fillRect zu zeichnen, wird schnell mühsam. LVGL ist eine Open-Source-Grafikbibliothek mit Widgets wie auf dem Smartphone (Tasten, Schieberegler, Listen, Diagramme, Tabs), die sich auch um die Touch-Eingabe kümmert. Seit Version 9 bringt sie die TFT_eSPI-Unterstützung gleich mit, sodass du keine eigene Flush-Funktion für das Display mehr schreiben musst.

  1. Installiere die Bibliothek lvgl (Version 9.x) über den Bibliotheksverwalter.
  2. Kopiere lv_conf_template.h aus dem Ordner libraries/lvgl eine Ebene höher, also neben den lvgl-Ordner, und nenne sie lv_conf.h.
  3. Ändere oben in der Datei #if 0 in #if 1 und setze LV_USE_TFT_ESPI auf 1.
  4. Für größere Schriften setze auch Zeilen wie LV_FONT_MONTSERRAT_20 auf 1; jede Schrift belegt Flash-Speicher.
C++ (Arduino IDE)
1#include <SPI.h>
2#include <lvgl.h>
3#include <TFT_eSPI.h>
4#include <XPT2046_Touchscreen.h>
5
6#define XPT2046_IRQ  36
7#define XPT2046_MOSI 32
8#define XPT2046_MISO 39
9#define XPT2046_CLK  25
10#define XPT2046_CS   33
11#define SCREEN_WIDTH  240
12#define SCREEN_HEIGHT 320
13#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8))
14
15SPIClass touchSpi(VSPI);
16XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
17uint32_t drawBuf[DRAW_BUF_SIZE / 4];   // ekranın 1/10'u kadar tampon / buffer for 1/10 of the screen
18lv_obj_t* valueLabel;
19
20// LVGL'e dokunuşu bildir / report touches to LVGL
21void touchRead(lv_indev_t* indev, lv_indev_data_t* data) {
22  if (ts.tirqTouched() && ts.touched()) {
23    TS_Point p = ts.getPoint();
24    data->point.x = map(p.x, 200, 3700, 1, SCREEN_WIDTH);
25    data->point.y = map(p.y, 240, 3800, 1, SCREEN_HEIGHT);
26    data->state = LV_INDEV_STATE_PRESSED;
27  } else {
28    data->state = LV_INDEV_STATE_RELEASED;
29  }
30}
31
32uint32_t tickMs() { return millis(); }   // LVGL'in saat kaynağı / LVGL time source
33
34void onLedButton(lv_event_t* e) {
35  lv_obj_t* btn = lv_event_get_target_obj(e);
36  bool on = lv_obj_has_state(btn, LV_STATE_CHECKED);
37  digitalWrite(4, on ? LOW : HIGH);      // kırmızı LED / red LED
38}
39
40void onSlider(lv_event_t* e) {
41  lv_obj_t* slider = lv_event_get_target_obj(e);
42  lv_label_set_text_fmt(valueLabel, "%d %%", (int)lv_slider_get_value(slider));
43}
44
45void lvglSetup() {
46  pinMode(4, OUTPUT);
47  digitalWrite(4, HIGH);
48  touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
49  ts.begin(touchSpi);
50  ts.setRotation(2);
51
52  lv_init();
53  lv_tick_set_cb(tickMs);
54  lv_display_t* disp = lv_tft_espi_create(SCREEN_WIDTH, SCREEN_HEIGHT, drawBuf, sizeof(drawBuf));
55  lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_270);   // yatay kullanım / landscape
56  lv_indev_t* indev = lv_indev_create();
57  lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
58  lv_indev_set_read_cb(indev, touchRead);
59
60  lv_obj_t* title = lv_label_create(lv_screen_active());
61  lv_label_set_text(title, "BlueGrays + LVGL");
62  lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 10);
63
64  lv_obj_t* btn = lv_button_create(lv_screen_active());
65  lv_obj_set_size(btn, 120, 50);
66  lv_obj_align(btn, LV_ALIGN_CENTER, 0, -30);
67  lv_obj_add_flag(btn, LV_OBJ_FLAG_CHECKABLE);              // aç-kapa düğmesi / toggle button
68  lv_obj_add_event_cb(btn, onLedButton, LV_EVENT_VALUE_CHANGED, NULL);
69  lv_obj_t* btnLabel = lv_label_create(btn);
70  lv_label_set_text(btnLabel, "LED");
71  lv_obj_center(btnLabel);
72
73  lv_obj_t* slider = lv_slider_create(lv_screen_active());
74  lv_obj_set_width(slider, 220);
75  lv_obj_align(slider, LV_ALIGN_CENTER, 0, 40);
76  lv_obj_add_event_cb(slider, onSlider, LV_EVENT_VALUE_CHANGED, NULL);
77  valueLabel = lv_label_create(lv_screen_active());
78  lv_label_set_text(valueLabel, "0 %");
79  lv_obj_align_to(valueLabel, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
80}
81
82void lvglLoop() {
83  lv_timer_handler();                    // LVGL çizim ve olayları / LVGL drawing and events
84  delay(5);
85}

Ergänze am Ende dieses Codes setup() und loop(): In setup() rufst du nur lvglSetup() auf, in loop() nur lvglLoop(). Das Bild wird über einen Puffer von einem Zehntel der Bildschirmgröße (etwa 15 KB) stückweise gezeichnet, ein guter Kompromiss für den CYD ohne PSRAM. Da LVGL die Drehung selbst übernimmt, werden die Touch-Koordinaten im Hochformat (240×320) übergeben und LVGL rechnet sie auf das Querformat um. Die Taste ist umschaltbar (checkable), jeder Tipp schaltet also die rote LED um, und der Schieberegler schreibt seinen Prozentwert in das Label darunter.

CYD Projektideen: Wetteranzeige und Smart-Home-Panel

  • Wetteranzeige: Zeige mit der ESP32-Wetter-API Temperatur, Luftfeuchtigkeit und Tagesvorhersage mit Symbolen an.
  • Smart-Home-Panel: Steuere Lampen und Steckdosen über MQTT und Home Assistant mit Bildschirmtasten.
  • Tischuhr: Zeige die Internetzeit per NTP in großen Ziffern und dimme die Beleuchtung nachts anhand des LDR.
  • Sensor-Dashboard: Stelle Temperatur, Feuchte und Luftdruck eines I2C-Sensors an CN1 als Live-Diagramm dar.
  • Datenlogger: Speichere Messwerte auf der microSD-Karte und zeige ein Diagramm der letzten 24 Stunden.
  • Touch-Spiele: Baue Tic-Tac-Toe, Snake oder Memory, die du mit dem Stift spielst.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
Display bleibt weiß oder schwarzUser_Setup.h nicht angepasst oder falscher TreiberEinstellungen aus diesem Artikel übernehmen; bei zwei USB-Buchsen ST7789 testen
Farben wie ein NegativTreiber oder Farbinvertierung passt nichttft.invertDisplay(1) ergänzen oder Treiber wechseln
Touch reagiert nichtTouch fälschlich am Display-SPI-Bus angenommentouchSpi(VSPI) mit den Pins 25, 32, 39, 33 nutzen
Berührung und Zeichnung versetztKalibrierwerte passen nicht zum BoardRohwerte der Ecken messen und map()-Zeilen anpassen
Flackern oder verzerrte LinienSPI-Takt zu hochSPI_FREQUENCY auf 27000000 senken
Neustart beim WLAN-StartUSB-Port oder Kabel liefert zu wenig StromKurzes, gutes Kabel und Netzteil mit mindestens 1 A verwenden
Upload startet nichtKein CH340-Treiber oder Board nicht im Download-ModusTreiber installieren und beim Upload-Start BOOT drücken
Startet das Board beim Verbinden mit dem WLAN immer wieder neu und zeigt der serielle Monitor "Brownout detector was triggered", liegt das Problem an der Stromversorgung, nicht am Code; Details findest du unter ESP32 Brownout und Guru Meditation.

Das Cheap Yellow Display ist der kürzeste Weg zu einem ESP32-Projekt mit Bildschirm: kein Kabelsalat, kein Löten, nur Code. Wenn du lieber mit einzelnen Modulen arbeitest, erklärt der Artikel ILI9341-TFT-Display denselben Treiber auf dem Steckbrett. In der BlueGrays-App findest du die Projekte Wetter, NTP-Uhr, Webserver und LDR mit Schritt-für-Schritt-Schaltplänen und Code und kannst sie auf das Display des CYD übertragen.

Häufige Fragen

Welches Board wähle ich in der Arduino IDE für das Cheap Yellow Display?

Wähle ESP32 Dev Module, denn auf dem CYD sitzt ein normales ESP32-WROOM-32-Modul. Die Flash-Größe bleibt bei 4 MB; schlägt der Upload fehl, senke die Geschwindigkeit auf 115200. Erscheint kein Port, installiere den CH340-Treiber.

Warum bleibt das Display des CYD weiß?

Ein weißes Display heißt: Die Hintergrundbeleuchtung ist an, aber der Displaytreiber bekommt keine gültigen Daten. Fast immer ist die User_Setup.h von TFT_eSPI nicht für den CYD angepasst oder der falsche Treiber gewählt. Prüfe die Pin-Einstellungen und teste bei Boards mit zwei USB-Buchsen den ST7789- statt des ILI9341-Treibers.

Welche Pins sind beim Cheap Yellow Display frei?

Nutzbar sind GPIO 22 und 27 am Stecker CN1 sowie GPIO 35 an P3, wobei GPIO 35 nur Eingang ist. Für I2C-Sensoren rufst du Wire.begin(27, 22) auf und versorgst den Sensor über 3,3 V und GND an CN1. GPIO 21 solltest du nicht verwenden, weil er die Hintergrundbeleuchtung steuert.

Läuft LVGL auf dem CYD ohne PSRAM?

Ja, LVGL 9 läuft flüssig auf dem CYD. Da kein PSRAM vorhanden ist, nutzt du einen Zeichenpuffer von einem Zehntel des Bildschirms (etwa 15 KB) statt eines ganzen Frames. Mit vielen großen Schriften oder Bildern werden Flash und RAM zur Grenze; deaktiviere ungenutzte Schriften in der lv_conf.h.

Kann ich Touch und SD-Karte gleichzeitig nutzen?

Ja, aber nur mit zusätzlicher Konfiguration, weil beide die VSPI-Hardware des ESP32 mit unterschiedlichen Pins verwenden. Am einfachsten ist eine Touch-Bibliothek mit Software-SPI. Alternativ startest du den SPI-Bus vor jedem Kartenzugriff mit den SD-Pins und danach wieder mit den Touch-Pins neu.

Kann das CYD mit Akku betrieben werden?

Das Board läuft mit 5 V und zieht mit Hintergrundbeleuchtung und WLAN meist 100–250 mA. Für Akkubetrieb nimmst du eine Li-Ionen-Zelle mit TP4056-Lademodul und 5-V-Aufwärtswandler oder einfach eine Powerbank. Für längere Laufzeit schaltest du Display und WLAN im Leerlauf ab und schickst den ESP32 in den Schlaf.

Alle Projekte ansehen
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

Messung der Lichtintensität mit dem ESP32-LDR-Modul

Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

4.6(36)
55
ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
ES-32Fortgeschritten
Premium

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)

Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

4.3(10)
22
ESP32 HTTPClient + Wetter-API (mit LCD-Display)
ES-31Fortgeschritten
Premium

ESP32 HTTPClient + Wetter-API (mit LCD-Display)

Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.

4.7(13)
20
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

ESP32: Echtzeit aus dem Internet per NTP

Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

4.5(13)
22
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

4.7(7)
12
ESP32 RGB-LED-Steuerung
ES-9Anfänger

ESP32 RGB-LED-Steuerung

Unbegrenzte Farberzeugung mit einer einzigen RGB-LED anstelle von 3 separaten LEDs. Wie in Arduino machen wir Regenbogenübergänge, indem wir R/G/B-Werte mit analogWrite() setzen. Die Farbtheorie (z. B. Rot+Grün=Gelb) wird praktisch umgesetzt.

4.6(29)
52
ESP32 Melodie-Wiedergabe mit Buzzer
ES-12Anfänger
Premium

ESP32 Melodie-Wiedergabe mit Buzzer

Spielen einer einfachen Melodie (Twinkle Twinkle Little Star) mit einem passiven Buzzer. Wir spielen die Noten mit den Funktionen tone() und noTone() wie in Arduino - die gleiche Syntax funktioniert mit ESP32 Arduino Core 3.0+. Es muss ein passiver Buzzer verwendet werden (ein aktiver Buzzer spielt keine Melodie).

4.8(30)
55