Komponen · 8 mnt baca

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.

Modul layar TFT 2,8 inci dengan driver ILI9341
Modul TFT ILI9341 yang dijual terpisah: layar 2,8 inci di CYD memakai driver yang sama; bedanya, ESP32 dan rangkaian sentuhnya berada di board yang sama.

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.

FiturNilai
Modul prosesorESP32-WROOM-32 (dual-core, 240 MHz)
MemoriSRAM 520 KB, flash 4 MB, tanpa PSRAM
LayarTFT 2,8 inci, 240×320 piksel, warna 16 bit (RGB565)
Driver layarILI9341 (biasanya ST7789 pada versi dua USB)
SentuhPanel resistif, pengontrol XPT2046
PenyimpananSlot kartu microSD (SPI)
TambahanLED RGB, sensor cahaya LDR, output speaker (penguat SC8002B)
USB dan dayaMicro-USB, chip USB-ke-serial CH340, 5 V
TombolBOOT (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.

BoardLayarCara mengenalinyaPerhatikan
ESP32-2432S028R (satu USB)2,8" 240×320, ILI9341Hanya port micro-USBVersi yang dipakai sebagian besar contoh, dan juga panduan ini
ESP32-2432S028R (dua USB)2,8" 240×320, biasanya ST7789Micro-USB dan USB-C berdampinganWarna bisa tampak terbalik; perlu ganti driver atau pengaturan invertDisplay
ESP32-2432S0242,4" 240×320Layar lebih kecilPin dan chip sentuh bisa berbeda
ESP32-2432S0323,2" 240×320Board lebih besarVersi kapasitif membaca sentuhan lewat I2C
ESP32-3248S0353,5" 320×480, ST7796Resolusi lebih tinggiPerlu pengaturan TFT_eSPI tersendiri
Pada CYD dengan dua port USB (micro-USB + USB-C), layarnya biasanya memakai driver ST7789. Dengan pengaturan ILI9341 layar mungkin tetap menyala, tetapi warnanya tampak seperti negatif film: putih menggantikan hitam, kuning menggantikan biru. Kalau begitu, pilih ST7789_DRIVER di User_Setup.h atau tambahkan tft.invertDisplay(1) tepat setelah tft.init().

Pinout CYD

BagianSinyal dan GPIOCatatan
Layar (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2Bus HSPI; RST tersambung ke EN
Lampu latarGPIO 21HIGH = menyala; bisa diredupkan dengan PWM
Sentuh (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36Bus VSPI, terpisah dari layar
microSDSCK 18, MISO 19, MOSI 23, CS 5Pin VSPI bawaan
LED RGBMerah 4, hijau 16, biru 17Common anode: LOW = menyala
Sensor cahaya LDRGPIO 34Hanya input, dibaca dengan analogRead
SpeakerGPIO 26Penguat SC8002B, konektor SPEAK
Tombol BOOTGPIO 0Bisa juga dibaca sebagai tombol di sketch-mu
Port serial (P1)TX 1, RX 3Berbagi dengan chip USB-ke-serial
Pin kosongGPIO 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.

GPIO 21 di konektor P3 juga menggerakkan lampu latar layar; kalau kamu menyambungkan sesuatu di sana dan menarik pin itu ke LOW, layar akan gelap. GPIO 35 hanya bekerja sebagai input, jadi tidak bisa menggerakkan LED atau relay. Ketika memberi daya komponen eksternal dari pin 3,3 V di CN1, jangan menarik arus ratusan miliampere dari sana; board ini sendiri sudah memakai arus yang cukup besar untuk layar dan Wi-Fi.

Pengaturan Arduino IDE: setelan board dan library

  1. Instal paket board ESP32 di Arduino IDE (esp32 by Espressif di Boards Manager) dan pilih ESP32 Dev Module sebagai board.
  2. Sambungkan board dengan kabel USB. Kalau port tidak muncul, instal driver CH340 dan pastikan kabelmu bisa membawa data, bukan hanya daya.
  3. Instal TFT_eSPI (Bodmer) dan XPT2046_Touchscreen (Paul Stoffregen) dari Library Manager.
  4. Ganti isi User_Setup.h di folder TFT_eSPI dengan pengaturan dari bagian berikutnya.
  5. 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.

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

Uji pertama: teks di layar dan menggambar dengan sentuhan

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}

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.

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}

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.

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}
Pengontrol sentuh dan kartu SD sama-sama memakai periferal VSPI, tetapi di pin yang berbeda. Kalau kamu butuh keduanya dalam satu sketch, pilih library yang membaca panel sentuh lewat SPI perangkat lunak (misalnya XPT2046_Bitbang), atau mulai ulang bus SPI dengan pin yang tepat sebelum dan sesudah setiap akses SD. Kalau tidak, salah satunya berhenti merespons selama yang lain dipakai.

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.

  1. Instal library lvgl (versi 9.x) dari Library Manager.
  2. 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.
  3. Ubah #if 0 di bagian atas file menjadi #if 1 dan atur LV_USE_TFT_ESPI ke 1.
  4. Untuk font yang lebih besar, atur juga baris seperti LV_FONT_MONTSERRAT_20 ke 1; setiap font memakan ruang di memori flash.
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}

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

GejalaKemungkinan penyebabSolusi
Layar tetap putih atau hitamUser_Setup.h belum diatur atau driver salahSalin pengaturan dari panduan ini; coba ST7789 pada board dua USB
Warna tampak seperti negatifDriver atau pengaturan inversi warna tidak cocokTambahkan tft.invertDisplay(1) atau ganti driver
Sentuh tidak meresponsSentuh dianggap berbagi bus SPI dengan layarPakai touchSpi(VSPI) dengan pin 25, 32, 39, 33
Titik sentuh dan gambar bergeserNilai kalibrasi tidak cocok dengan boardUkur nilai mentah di sudut-sudut lalu perbarui baris map()
Layar berkedip atau garis kacauClock SPI terlalu tinggiTurunkan SPI_FREQUENCY ke 27000000
Reset begitu Wi-Fi menyalaPort USB atau kabel tidak sanggup memasok arus yang cukupPakai kabel pendek yang bagus dan adaptor minimal 1 A
Upload tidak mulaiDriver CH340 belum ada atau board tidak dalam mode downloadInstal driver dan tekan BOOT begitu upload dimulai
Kalau board terus restart ketika menyambung ke Wi-Fi dan Serial Monitor menampilkan “Brownout detector was triggered”, masalahnya ada di catu daya, bukan di kodemu; detailnya ada di error brownout dan Guru Meditation pada ESP32.

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.

Lihat semua proyek
Membaca Intensitas Cahaya dengan Modul LDR ESP32
ES-11Pemula

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.

4.6(36)
55
HTTPClient + API Cuaca ESP32 (dengan Layar OLED SSD1306)
ES-32Mahir
Premium

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).

4.3(10)
22
HTTPClient + API Cuaca ESP32 (dengan Layar LCD)
ES-31Mahir
Premium

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.

4.7(13)
20
Jam Real-Time dari Internet lewat NTP ESP32
ES-26Mahir
Premium

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.

4.5(13)
22
Web Server Asinkron ESP32 (dengan Tampilan IP di LCD)
ES-27Mahir

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.

4.8(16)
26
Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)
ES-40Mahir
Premium

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.

4.7(7)
12
Kendali LED RGB ESP32
ES-9Pemula

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.

4.6(29)
52
Memutar Melodi dengan Buzzer ESP32
ES-12Pemula
Premium

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).

4.8(30)
55