ESP32 Cheap Yellow Display (CYD): pinout, pengaturan, dan LVGL
Panduan ESP32 Cheap Yellow Display (ESP32-2432S028R): pinout lengkap, pengaturan TFT_eSPI dan sentuh XPT2046, kalibrasi, kartu SD, speaker, dan antarmuka LVGL pertama.
ESP32 Cheap Yellow Display (disingkat CYD), yang dijual dengan nama model ESP32-2432S028R, adalah board pengembangan siap pakai yang menyatukan ESP32, layar sentuh berwarna 2,8 inci, slot microSD, LED RGB, sensor cahaya, dan output speaker di satu PCB kuning. Julukannya sudah menjelaskan semuanya: board-nya kuning, murah, dan punya layar. Colokkan satu kabel USB, upload sketch-mu, dan kamu langsung punya antarmuka sentuh tanpa menyolder apa pun atau memasang satu kabel jumper pun.
Di panduan ini kamu akan melihat apa saja yang ada di board, cara membedakan versinya, dan pinout lengkapnya. Setelah itu kamu akan mengatur library TFT_eSPI dan XPT2046_Touchscreen di Arduino IDE, menampilkan teks di layar, mengalibrasi panel sentuh, menyalakan dan mematikan LED RGB lewat tombol di layar, mencatat data ke kartu microSD, dan membuat antarmuka sungguhan pertamamu dengan LVGL. Bagian-bagian terakhir membahas ide proyek seperti layar cuaca dan panel rumah pintar, plus solusi untuk masalah yang paling sering muncul.

Apa itu ESP32 Cheap Yellow Display dan apa saja yang ada di board-nya?
Di jantung board ini ada modul ESP32-WROOM-32: prosesor dual-core yang berjalan hingga 240 MHz, SRAM 520 KB, flash 4 MB, Wi-Fi 2,4 GHz, dan Bluetooth. Semua yang kamu pelajari di Apa Itu ESP32? berlaku juga di sini. Layarnya tersambung ke bus HSPI milik ESP32, sedangkan chip XPT2046 yang membaca panel sentuh resistif berada di bus SPI kedua (VSPI) dengan pin-pinnya sendiri. Detail ini penting, karena contoh TFT umum di internet menganggap sentuh berbagi bus dengan layar, sehingga tidak jalan di CYD. Board ini tidak punya PSRAM, jadi gambar tidak disimpan utuh di memori, melainkan digambar sepotong demi sepotong.
| Fitur | Nilai |
|---|---|
| Modul prosesor | ESP32-WROOM-32 (dual-core, 240 MHz) |
| Memori | SRAM 520 KB, flash 4 MB, tanpa PSRAM |
| Layar | TFT 2,8 inci, 240×320 piksel, warna 16 bit (RGB565) |
| Driver layar | ILI9341 (biasanya ST7789 pada versi dua USB) |
| Sentuh | Panel resistif, pengontrol XPT2046 |
| Penyimpanan | Slot kartu microSD (SPI) |
| Tambahan | LED RGB, sensor cahaya LDR, output speaker (penguat SC8002B) |
| USB dan daya | Micro-USB, chip USB-ke-serial CH340, 5 V |
| Tombol | BOOT (GPIO 0) dan RST |
Versi board: apa arti nama ESP32-2432S028R?
Nama modelnya sebenarnya sebuah ringkasan: 2432 adalah resolusi (240×320), S028 ukuran layar (2,8 inci), dan huruf R di akhir berarti sentuh resistif. Di keluarga yang sama ada juga board berakhiran C (sentuh kapasitif) dan N (tanpa sentuh). Karena penjual menyebut semuanya “Cheap Yellow Display”, periksa nama model lengkapnya sebelum memesan: susunan pin dan driver layar bisa berbeda dari satu versi ke versi lain.
| Board | Layar | Cara mengenalinya | Perhatikan |
|---|---|---|---|
| ESP32-2432S028R (satu USB) | 2,8" 240×320, ILI9341 | Hanya port micro-USB | Versi yang dipakai sebagian besar contoh, dan juga panduan ini |
| ESP32-2432S028R (dua USB) | 2,8" 240×320, biasanya ST7789 | Micro-USB dan USB-C berdampingan | Warna bisa tampak terbalik; perlu ganti driver atau pengaturan invertDisplay |
| ESP32-2432S024 | 2,4" 240×320 | Layar lebih kecil | Pin dan chip sentuh bisa berbeda |
| ESP32-2432S032 | 3,2" 240×320 | Board lebih besar | Versi kapasitif membaca sentuhan lewat I2C |
| ESP32-3248S035 | 3,5" 320×480, ST7796 | Resolusi lebih tinggi | Perlu pengaturan TFT_eSPI tersendiri |
Pinout CYD
| Bagian | Sinyal dan GPIO | Catatan |
|---|---|---|
| Layar (ILI9341) | MOSI 13, MISO 12, SCK 14, CS 15, DC 2 | Bus HSPI; RST tersambung ke EN |
| Lampu latar | GPIO 21 | HIGH = menyala; bisa diredupkan dengan PWM |
| Sentuh (XPT2046) | CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36 | Bus VSPI, terpisah dari layar |
| microSD | SCK 18, MISO 19, MOSI 23, CS 5 | Pin VSPI bawaan |
| LED RGB | Merah 4, hijau 16, biru 17 | Common anode: LOW = menyala |
| Sensor cahaya LDR | GPIO 34 | Hanya input, dibaca dengan analogRead |
| Speaker | GPIO 26 | Penguat SC8002B, konektor SPEAK |
| Tombol BOOT | GPIO 0 | Bisa juga dibaca sebagai tombol di sketch-mu |
| Port serial (P1) | TX 1, RX 3 | Berbagi dengan chip USB-ke-serial |
| Pin kosong | GPIO 22, 27 (CN1), GPIO 35 (P3) | 35 hanya input |
Konektor JST kecil (jarak pin 1,25 mm) di tepi board adalah pintumu ke dunia luar. CN1 membawa GND, GPIO 22, GPIO 27, dan 3,3 V, pas sekali untuk sensor I2C: panggil Wire.begin(27, 22) lalu colokkan langsung sensor seperti BME280. P3 mengeluarkan GPIO 35, 22, dan 21, sedangkan P1 membawa input 5 V serta jalur serial TX/RX. Untuk mencocokkan pin-pin ini dengan batasan umum ESP32, buka alat Pinout.
Pengaturan Arduino IDE: setelan board dan library
- Instal paket board ESP32 di Arduino IDE (esp32 by Espressif di Boards Manager) dan pilih ESP32 Dev Module sebagai board.
- Sambungkan board dengan kabel USB. Kalau port tidak muncul, instal driver CH340 dan pastikan kabelmu bisa membawa data, bukan hanya daya.
- Instal TFT_eSPI (Bodmer) dan XPT2046_Touchscreen (Paul Stoffregen) dari Library Manager.
- Ganti isi User_Setup.h di folder TFT_eSPI dengan pengaturan dari bagian berikutnya.
- Kalau upload berhenti dengan pesan “Failed to connect”, tahan tombol BOOT ketika upload dimulai; detailnya ada di ESP32 Failed to connect.
Konfigurasi TFT_eSPI: User_Setup.h
TFT_eSPI adalah library yang sangat cepat, dan kecepatan itu didapat dari pengaturan pin yang dikunci ketika kompilasi. Pengaturannya ada di file User_Setup.h di dalam folder library (Documents > Arduino > libraries > TFT_eSPI). Cadangkan file itu, hapus seluruh isinya, lalu tempel baris-baris di bawah. Memperbarui library akan mengembalikan file ini ke bawaannya, jadi simpan salinanmu sendiri di tempat yang aman dan salin kembali setiap kali selesai memperbarui.
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 2500000Uji pertama: teks di layar dan menggambar dengan sentuhan
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}Baris kuncinya adalah SPIClass touchSpi(VSPI): baris ini menempatkan pengontrol sentuh di bus SPI kedua dengan pin-pinnya sendiri, terpisah dari layar. ts.setRotation(1) dan tft.setRotation(1) harus memakai nilai yang sama; kalau berbeda, titik yang kamu sentuh dan titik yang digambar di layar tidak akan cocok. Dalam posisi lanskap, koordinat berjalan dari 0 sampai 319 untuk x dan 0 sampai 239 untuk y. Setelah meng-upload, coba menulis di layar dengan stylus; kalau garisnya mengikuti tanganmu, layar dan sentuh sudah diatur dengan benar.
Kalibrasi layar sentuh (XPT2046)
XPT2046 tidak melaporkan piksel, melainkan nilai mentah antara 0 dan 4095. Angka 200, 3700 dan 240, 3800 di kode adalah bagian dari rentang mentah itu yang bertepatan dengan tepi layar, dan nilainya sedikit berbeda di setiap board. Untuk mengalibrasi, buka Serial Monitor pada 115200 baud, ketuk keempat sudut dengan stylus, dan catat nilai mentah x dan y yang terkecil dan terbesar. Masukkan keempat angka itu ke baris map(), maka selisih antara sentuhanmu dan titik yang digambar turun menjadi beberapa piksel saja. Panel resistif juga mengukur tekanan: touched() milik library memang hanya mengembalikan true untuk tekanan yang cukup kuat, tetapi kalau kamu melihat nilai yang bergetar di dekat tepi, kamu bisa menambahkan ambang yang lebih tinggi untuk p.z.
LED RGB, LDR, dan speaker: panel kontrol sentuh
LED RGB, LDR, dan output speaker di bagian belakang board sudah cukup untuk proyek pertamamu. Kode di bawah menggambar tiga tombol besar; mengetuk sebuah tombol menyalakan atau mematikan warna LED itu dan membunyikan klik singkat di speaker. Batang kuning di bagian bawah menampilkan pembacaan sensor cahaya dan diperbarui setiap setengah detik.
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}Karena LED RGB dirangkai sebagai common anode, logikanya terbalik: menulis LOW menyalakan sebuah warna dan HIGH mematikannya, itulah sebabnya setup() lebih dulu mengatur ketiga pin ke HIGH. Variabel wasTouched mencegah tombol berganti keadaan berulang-ulang selama jarimu masih menempel di layar; yang dihitung hanya momen ketika sentuhan dimulai. Pembacaan LDR bisa saja bertahan di rentang yang sempit karena resistor pembagi di board, jadi ukur nilai gelap dan terang di ruanganmu sendiri lalu tentukan ambang dari situ. Kamu bisa mencolokkan speaker kecil 8 Ω ke konektor speaker dan memainkan bunyi bip serta melodi sederhana dengan tone().
Mencatat data ke kartu microSD
Slot kartu memakai pin VSPI bawaan ESP32 (18, 19, 23, dan 5 untuk CS), jadi SD.begin(5) saja sudah cukup. Format kartu sebagai FAT32; kartu hingga 32 GB bekerja tanpa masalah. Contoh di bawah menambahkan waktu dan tingkat cahaya ke log.csv setiap lima detik, dan file itu nanti bisa kamu buka di program spreadsheet apa pun. Untuk penggunaan kartu SD secara umum, lihat panduan modul kartu SD.
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}Antarmuka pertamamu dengan LVGL
Menggambar tombol, slider, dan grafik satu per satu dengan fillRect cepat terasa melelahkan. LVGL adalah library grafis open source yang memberimu widget bergaya ponsel (tombol, slider, daftar, grafik, tab) dan menangani input sentuh untukmu. Sejak versi 9, dukungan TFT_eSPI sudah bawaan, jadi kamu tidak perlu lagi menulis fungsi flush sendiri untuk layar.
- Instal library lvgl (versi 9.x) dari Library Manager.
- Salin lv_conf_template.h dari folder libraries/lvgl ke satu tingkat di atasnya, di samping folder lvgl, dan ganti namanya menjadi lv_conf.h.
- Ubah #if 0 di bagian atas file menjadi #if 1 dan atur LV_USE_TFT_ESPI ke 1.
- Untuk font yang lebih besar, atur juga baris seperti LV_FONT_MONTSERRAT_20 ke 1; setiap font memakan ruang di memori flash.
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}Tambahkan setup() dan loop() di akhir kode ini: panggil hanya lvglSetup() di setup() dan hanya lvglLoop() di loop(). Layar digambar sepotong demi sepotong lewat buffer berukuran sepersepuluh layar (sekitar 15 KB), keseimbangan yang pas untuk CYD tanpa PSRAM. Karena LVGL menangani rotasinya sendiri, koordinat sentuh diberikan dalam urutan potret (240×320) dan LVGL memetakannya ke layar lanskap. Tombolnya bertipe checkable, jadi setiap ketukan mengubah keadaan LED merah, dan slider menuliskan nilai persennya ke label di bawahnya.
Ide proyek CYD: stasiun cuaca dan panel rumah pintar
- Layar cuaca: Ikuti panduan API cuaca ESP32 untuk menampilkan suhu, kelembapan, dan prakiraan harian dengan ikon.
- Panel rumah pintar: Kendalikan lampu dan stopkontak dengan tombol di layar lewat MQTT dan Home Assistant.
- Jam meja: Tampilkan waktu internet dari NTP dengan angka besar dan redupkan lampu latar di malam hari berdasarkan LDR.
- Dasbor sensor: Tampilkan suhu, kelembapan, dan tekanan dari sensor I2C di CN1 sebagai grafik langsung.
- Pencatat data: Simpan pembacaan ke kartu microSD dan tampilkan grafik 24 jam terakhir.
- Game sentuh: Buat game tic-tac-toe, ular, atau memori yang dimainkan dengan stylus.
Masalah umum dan solusinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Layar tetap putih atau hitam | User_Setup.h belum diatur atau driver salah | Salin pengaturan dari panduan ini; coba ST7789 pada board dua USB |
| Warna tampak seperti negatif | Driver atau pengaturan inversi warna tidak cocok | Tambahkan tft.invertDisplay(1) atau ganti driver |
| Sentuh tidak merespons | Sentuh dianggap berbagi bus SPI dengan layar | Pakai touchSpi(VSPI) dengan pin 25, 32, 39, 33 |
| Titik sentuh dan gambar bergeser | Nilai kalibrasi tidak cocok dengan board | Ukur nilai mentah di sudut-sudut lalu perbarui baris map() |
| Layar berkedip atau garis kacau | Clock SPI terlalu tinggi | Turunkan SPI_FREQUENCY ke 27000000 |
| Reset begitu Wi-Fi menyala | Port USB atau kabel tidak sanggup memasok arus yang cukup | Pakai kabel pendek yang bagus dan adaptor minimal 1 A |
| Upload tidak mulai | Driver CH340 belum ada atau board tidak dalam mode download | Instal driver dan tekan BOOT begitu upload dimulai |
ESP32 Cheap Yellow Display adalah jalan terpendek menuju proyek ESP32 berlayar: tanpa kabel kusut, tanpa menyolder, cukup kode. Kalau kamu lebih suka bekerja dengan modul terpisah, panduan layar TFT ILI9341 membahas driver yang sama di breadboard. Di aplikasi BlueGrays kamu bisa menemukan proyek cuaca, jam NTP, web server, dan LDR lengkap dengan skema rangkaian dan kode langkah demi langkah, siap dipindahkan ke layar CYD.
Pertanyaan umum
Board apa yang dipilih untuk Cheap Yellow Display di Arduino IDE?
Pilih ESP32 Dev Module, karena CYD membawa modul ESP32-WROOM-32 standar. Biarkan ukuran flash di 4 MB dan turunkan kecepatan upload ke 115200 kalau upload gagal. Kalau port tidak muncul, instal driver CH340.
Kenapa layar CYD-ku putih?
Layar putih berarti lampu latar menyala tetapi driver layar tidak menerima data yang valid. Hampir selalu penyebabnya file User_Setup.h milik TFT_eSPI belum diatur untuk CYD atau driver yang dipilih salah. Periksa pengaturan pin, dan pada board dengan dua port USB coba driver ST7789 sebagai pengganti ILI9341.
Pin GPIO mana yang bisa dipakai di ESP32 Cheap Yellow Display?
Pin yang bisa dipakai adalah GPIO 22 dan 27 di konektor CN1 serta GPIO 35 di P3; GPIO 35 hanya input. Untuk sensor I2C, panggil Wire.begin(27, 22) dan beri daya sensor dari pin 3,3 V dan GND di CN1. Jangan ganggu GPIO 21, karena pin itu menggerakkan lampu latar.
Apakah LVGL bisa berjalan di CYD tanpa PSRAM?
Ya, LVGL 9 berjalan mulus di CYD. Karena tidak ada PSRAM, kamu memakai buffer gambar sebesar sepersepuluh layar (sekitar 15 KB), bukan satu frame penuh. Kalau kamu menambahkan banyak font besar atau gambar, flash dan RAM-lah yang menjadi batas sebenarnya, jadi nonaktifkan font yang tidak kamu pakai di lv_conf.h.
Bisakah layar sentuh dan kartu SD dipakai bersamaan?
Bisa, tetapi perlu pengaturan tambahan, karena keduanya memakai periferal VSPI milik ESP32 di pin yang berbeda. Cara termudah adalah library sentuh yang memakai SPI perangkat lunak. Pilihan lainnya, mulai ulang bus SPI dengan pin SD sebelum setiap akses kartu dan dengan pin sentuh sesudahnya.
Bisakah Cheap Yellow Display dijalankan dengan baterai?
Board ini bekerja pada 5 V dan biasanya menarik 100–250 mA ketika lampu latar dan Wi-Fi menyala. Untuk daya baterai, pakai sel Li-ion dengan charger TP4056 dan boost converter 5 V, atau cukup power bank. Agar baterai lebih awet, matikan layar dan Wi-Fi ketika tidak dipakai dan tidurkan ESP32.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Membaca Intensitas Cahaya dengan Modul LDR ESP32
Memantau secara real-time di Serial Monitor nilai ADC mentah modul LDR dan persentase cahaya relatif yang dihitung dari nilai acuan gelap dan terang. Persentase ini bukan pengukuran lux. Mengajarkan logika kalibrasi modul. Ideal dikerjakan sebelum Proyek 10, karena dipakai untuk menentukan nilai ambang.

HTTPClient + API Cuaca ESP32 (dengan Layar OLED SSD1306)
Di proyek ini, kita memakai ESP32 untuk melakukan panggilan REST API ke API cuaca (wttr.in) lewat internet dengan HTTPClient.h. Berbeda dengan versi LCD I2C sebelumnya, di sini kita memakai layar OLED SSD1306 (128×64), yang memungkinkan font besar, ikon vektor, dan tampilan visual yang kaya di satu layar. Tujuh ikon vektor untuk kondisi cuaca (cerah, berawan sebagian, berawan, hujan, salju, badai, berkabut) digambar ketika program berjalan (tanpa file bitmap).

HTTPClient + API Cuaca ESP32 (dengan Layar LCD)
Di proyek ini, kita memakai ESP32 untuk melakukan panggilan REST API ke API cuaca (wttr.in) lewat internet dengan HTTPClient.h. Kita mengurai respons JSON yang diterima dengan ArduinoJson v7 dan menampilkan kota, suhu, kelembapan, cuaca, dan informasi angin di layar LCD I2C dalam bahasa Turki dan Inggris. wttr.in gratis dan tidak butuh kunci API; kamu cukup memasukkan nama kota apa pun untuk mengambil kondisi cuaca terkini kota itu. Data diperbarui otomatis setiap 30 menit.

Jam Real-Time dari Internet lewat NTP ESP32
ESP32 tersambung ke Wi-Fi dan mengambil waktu nyata dengan presisi milidetik dari server NTP (Network Time Protocol). Berkat fungsi configTzTime(), zona waktu Turki (TRT, UTC+3) otomatis diterapkan, dan pergantian DST di negara yang memakai waktu musim panas otomatis diatur dengan string POSIX TZ. Waktunya ditampilkan di Serial Monitor sekaligus di LCD I2C opsional. configTzTime() memulai layanan SNTP; sinkronisasi ulang berkala terjadi selama koneksi tersedia.

Web Server Asinkron ESP32 (dengan Tampilan IP di LCD)
Di proyek ini, kita mengubah ESP32 menjadi web server asinkron yang bisa kamu kendalikan dari ponsel atau komputer di jaringan Wi-Fi yang sama. Berkat library ESPAsyncWebServer, server bisa memproses beberapa permintaan bersamaan (berbeda dengan WebServer.h klasik, yang memblokir pada satu permintaan). Kamu bisa membuka alamat IP ESP32 di browser dan mengklik tombol ON/OFF (rute /on dan /off) untuk menyalakan dan mematikan LED yang tersambung ke GPIO 5.

Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)
Buat pencatat suhu bercap waktu dengan ESP32! Baca suhu/kelembapan DHT22 setiap menit, ambil waktu sebenarnya dari RTC DS1307, dan catat ke kartu microSD sebagai CSV. OLED menampilkan suhu langsung (font besar), kelembapan, cap waktu, dan penghitung catatan. File /temp_log.csv bisa dibuka di Excel, Google Sheets, atau Python pandas; cocok untuk rumah kaca, suhu kamar, data laboratorium, penyimpanan makanan, atau sarang lebah.

Kendali LED RGB ESP32
Menghasilkan warna tanpa batas dengan satu LED RGB alih-alih 3 LED terpisah. Seperti di Arduino, kita membuat transisi pelangi dengan mengatur nilai R/G/B lewat analogWrite(). Teori warna (seperti merah+hijau=kuning) terlihat secara praktis.

Memutar Melodi dengan Buzzer ESP32
Memainkan melodi sederhana (Twinkle Twinkle Little Star) dengan buzzer pasif. Kita memainkan nada dengan fungsi tone() dan noTone() seperti di Arduino; ESP32 bekerja dengan sintaks yang sama di Arduino Core 3.0+. Harus memakai buzzer pasif (buzzer aktif tidak bisa memainkan melodi).
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

