ESP32 Cheap Yellow Display (CYD): Pinler, Kurulum ve LVGL
ESP32 Cheap Yellow Display (ESP32-2432S028R) rehberi: pin tablosu, TFT_eSPI ve XPT2046 ayarı, dokunmatik kalibrasyonu, SD kart, hoparlör ve LVGL arayüzü.
ESP32 Cheap Yellow Display (kısaca CYD), resmî model adıyla ESP32-2432S028R, bir ESP32 işlemciyi, 2,8 inç renkli dokunmatik ekranı, microSD kart yuvasını, RGB LED'i, ışık sensörünü ve hoparlör çıkışını tek bir sarı devre kartında toplayan hazır bir geliştirme kartıdır. Adı da buradan gelir: kart sarıdır, ucuzdur ve üzerinde ekran vardır. Tek bir USB kablosu takıp kodu yüklediğinde lehim yapmadan, tek bir jumper kablo bile bağlamadan dokunmatik bir arayüze sahip olursun.
Bu yazıda kartın üzerinde neler olduğunu, sürümleri nasıl ayırt edeceğini ve tam pin tablosunu göreceksin. Ardından Arduino IDE'de TFT_eSPI ve XPT2046_Touchscreen kütüphanelerini doğru ayarlayıp ekrana yazı yazacak, dokunmatiği kalibre edecek, RGB LED'i ekrandaki düğmelerle yakacak, microSD karta veri kaydedecek ve LVGL ile ilk gerçek arayüzünü kuracaksın. Son bölümde hava durumu ekranı ve akıllı ev paneli gibi proje fikirleri ile en sık karşılaşılan sorunların çözümleri var.

ESP32 Cheap Yellow Display nedir, kartta neler var?
Kartın kalbinde bir ESP32-WROOM-32 modülü bulunur: 240 MHz'e kadar çalışan çift çekirdekli işlemci, 520 KB SRAM, 4 MB flash bellek, 2,4 GHz Wi-Fi ve Bluetooth. Yani ESP32 Nedir? yazısında öğrendiğin her şey burada da geçerlidir. Ekran, ESP32'nin HSPI hattına bağlıdır; dirençli dokunmatik paneli okuyan XPT2046 yongası ise ayrı pinlerle ikinci SPI hattına (VSPI) bağlanmıştır. Bu ayrıntı önemlidir, çünkü internetteki genel TFT örnekleri dokunmatiğin ekranla aynı hatta olduğunu varsayar ve CYD'de çalışmaz. Kartta PSRAM yoktur; bu yüzden ekranın tamamını bellekte tutmak yerine görüntü parça parça çizilir.
| Özellik | Değer |
|---|---|
| İşlemci modülü | ESP32-WROOM-32 (çift çekirdek, 240 MHz) |
| Bellek | 520 KB SRAM, 4 MB flash, PSRAM yok |
| Ekran | 2,8 inç TFT, 240×320 piksel, 16 bit renk (RGB565) |
| Ekran sürücüsü | ILI9341 (iki USB'li sürümde çoğunlukla ST7789) |
| Dokunmatik | Dirençli panel, XPT2046 denetleyici |
| Depolama | microSD kart yuvası (SPI) |
| Ek donanım | RGB LED, LDR ışık sensörü, hoparlör çıkışı (SC8002B yükselteç) |
| USB ve besleme | micro-USB, CH340 USB-seri yonga, 5 V |
| Düğmeler | BOOT (GPIO 0) ve RST |
Kart sürümleri: ESP32-2432S028R adı ne anlatıyor?
Model adı aslında bir özettir: 2432 çözünürlüğü (240×320), S028 ekran boyutunu (2,8 inç), sondaki R ise dirençli (resistive) dokunmatiği gösterir. Aynı ailede C harfiyle biten kapasitif dokunmatikli ve N harfiyle biten dokunmatiksiz kartlar da vardır. Satıcılar hepsine "Cheap Yellow Display" diyebildiği için sipariş vermeden önce tam model adına bakmalısın; pin düzeni ve ekran sürücüsü sürümden sürüme değişebilir.
| Kart | Ekran | Nasıl tanınır | Dikkat |
|---|---|---|---|
| ESP32-2432S028R (tek USB) | 2,8" 240×320, ILI9341 | Yalnız micro-USB girişi | Örneklerin ve bu yazının temel aldığı sürüm |
| ESP32-2432S028R (iki USB) | 2,8" 240×320, çoğunlukla ST7789 | micro-USB ve USB-C birlikte | Renkler ters görünebilir; sürücü ya da invertDisplay ayarı gerekir |
| ESP32-2432S024 | 2,4" 240×320 | Daha küçük ekran | Pinler ve dokunmatik yongası farklı olabilir |
| ESP32-2432S032 | 3,2" 240×320 | Daha büyük kart | Kapasitif sürümde dokunmatik I2C ile okunur |
| ESP32-3248S035 | 3,5" 320×480, ST7796 | Daha yüksek çözünürlük | Ayrı bir TFT_eSPI ayarı gerekir |
CYD pin tablosu
| Parça | Sinyal ve GPIO | Not |
|---|---|---|
| Ekran (ILI9341) | MOSI 13, MISO 12, SCK 14, CS 15, DC 2 | HSPI hattı; RST ucu EN'e bağlı |
| Arka ışık | GPIO 21 | HIGH = açık; PWM ile kısılabilir |
| Dokunmatik (XPT2046) | CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36 | VSPI hattı, ekrandan ayrı |
| microSD | SCK 18, MISO 19, MOSI 23, CS 5 | VSPI'nin varsayılan pinleri |
| RGB LED | Kırmızı 4, yeşil 16, mavi 17 | Ortak anot: LOW = yanar |
| LDR ışık sensörü | GPIO 34 | Yalnız giriş, analogRead ile okunur |
| Hoparlör | GPIO 26 | SC8002B yükselteç, SPEAK konnektörü |
| BOOT düğmesi | GPIO 0 | Programda düğme olarak da okunabilir |
| Seri port (P1) | TX 1, RX 3 | USB-seri yongayla ortak |
| Boş pinler | GPIO 22, 27 (CN1), GPIO 35 (P3) | 35 yalnız giriştir |
Kartın kenarındaki küçük JST konnektörler (1,25 mm aralıklı) dış dünyaya açılan kapındır. CN1 konnektöründe GND, GPIO 22, GPIO 27 ve 3,3 V bulunur; bu dört uç bir I2C sensörü için idealdir: Wire.begin(27, 22) yazıp BME280 gibi bir sensörü doğrudan bağlayabilirsin. P3 konnektöründe GPIO 35, 22 ve 21 vardır; P1 ise 5 V girişi ile seri port (TX/RX) uçlarını taşır. Pinleri ESP32'nin genel kısıtlarıyla birlikte görmek için pin haritası aracına bakabilirsin.
Arduino IDE kurulumu: kart ayarı ve kütüphaneler
- Arduino IDE'ye ESP32 kart paketini kur (Kart Yöneticisi'nde esp32 by Espressif) ve kart olarak ESP32 Dev Module seç.
- Kartı USB kablosuyla bağla. Port görünmüyorsa bilgisayarına CH340 sürücüsünü kur ve yalnız şarj eden değil, veri de taşıyan bir kablo kullandığından emin ol.
- Kütüphane Yöneticisi'nden TFT_eSPI (Bodmer) ve XPT2046_Touchscreen (Paul Stoffregen) kütüphanelerini kur.
- TFT_eSPI klasöründeki User_Setup.h dosyasının içeriğini bir sonraki bölümdeki ayarlarla değiştir.
- Yükleme sırasında "Failed to connect" hatası alırsan yükleme başlarken BOOT düğmesini basılı tut; ayrıntılar ESP32 Failed to connect yazısında.
TFT_eSPI ayarı: User_Setup.h
TFT_eSPI çok hızlı bir kütüphanedir, ama bu hızı derleme sırasında sabitlenen pin ayarlarından alır. Ayarlar kütüphanenin kendi klasöründeki User_Setup.h dosyasında durur (Belgeler > Arduino > libraries > TFT_eSPI). Dosyanın yedeğini al, içindeki her şeyi sil ve aşağıdaki satırları yapıştır. Kütüphaneyi güncellediğinde bu dosya varsayılan hâline döner; bu yüzden kendi sürümünü ayrı bir yerde sakla ve her güncellemeden sonra geri kopyala.
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İlk test: ekrana yazı ve dokunmatikle çizim
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}Kodun en önemli satırı SPIClass touchSpi(VSPI) satırıdır: dokunmatik denetleyiciyi ekrandan bağımsız olarak, kendi pinleriyle ikinci SPI hattına bağlar. ts.setRotation(1) ve tft.setRotation(1) aynı değeri almalıdır; ikisi farklı olursa parmağının dokunduğu yer ile ekranda çizilen nokta birbirini tutmaz. Ekran yatay kullanıldığında koordinatlar x için 0–319, y için 0–239 aralığındadır. Kodu yükledikten sonra ekrana bir kalem ucuyla yazı yazmayı dene; çizgiler parmağını takip ediyorsa ekran ve dokunmatik doğru ayarlanmış demektir.
Dokunmatik kalibrasyonu (XPT2046)
XPT2046 piksel değil, 0 ile 4095 arasında ham değerler verir. Koddaki 200, 3700 ve 240, 3800 sayıları bu ham aralığın ekran kenarlarına denk gelen kısmıdır ve her kartta biraz farklıdır. Kalibrasyon için Seri Monitör'ü 115200 baud ile aç, bir kalem ucuyla sırayla dört köşeye dokun ve en küçük ve en büyük ham x ile y değerlerini not et. Bu dört sayıyı map() satırlarına yazdığında dokunuşla çizilen nokta arasındaki kayma birkaç piksele iner. Dirençli panel basıncı da ölçer: kütüphanenin touched() fonksiyonu zaten yalnız yeterince güçlü basışlarda true döner, yine de kenarlarda titreyen değerler görürsen p.z için daha yüksek bir eşik koyabilirsin.
RGB LED, LDR ve hoparlör: dokunmatik kontrol paneli
Kartın arka yüzündeki RGB LED, LDR ve hoparlör çıkışı ilk projen için yeterli malzemedir. Aşağıdaki kod ekrana üç büyük düğme çizer; dokunduğun düğme LED'in o rengini açıp kapatır ve hoparlörden kısa bir tık sesi gelir. Alt kısımdaki sarı çubuk ise ışık sensöründen okunan değeri yarım saniyede bir günceller.
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}RGB LED ortak anotlu bağlandığı için mantık terstir: pine LOW yazınca ilgili renk yanar, HIGH yazınca söner; bu yüzden setup() içinde üç pin de önce HIGH yapılır. wasTouched değişkeni, parmağın ekranda kaldığı sürece düğmenin defalarca açılıp kapanmasını engeller; yalnız dokunuşun başladığı an sayılır. LDR değeri kartın bölücü direncine bağlı olarak dar bir aralıkta kalabilir; kendi odanda karanlık ve aydınlık değerleri ölçüp eşiği ona göre belirle. Hoparlör çıkışına 8 Ω'luk küçük bir hoparlör takabilir, tone() ile bip sesleri ve basit melodiler çalabilirsin.
microSD karta veri kaydetmek
Kart yuvası ESP32'nin varsayılan VSPI pinlerine (18, 19, 23 ve CS için 5) bağlıdır; bu yüzden SD.begin(5) yazmak yeterlidir. Kartı FAT32 olarak biçimlendir; 32 GB'a kadar kartlar sorunsuz çalışır. Aşağıdaki örnek her beş saniyede bir zamanı ve ışık seviyesini log.csv dosyasına ekler; dosyayı daha sonra bilgisayarda bir tablo programıyla açabilirsin. SD kartların genel kullanımı için SD kart modülü yazısına bakabilirsin.
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}LVGL ile ilk arayüz
Düğmeleri, kaydırıcıları ve grafikleri tek tek fillRect ile çizmek bir noktadan sonra yorucu olur. LVGL, telefon arayüzlerine benzeyen nesneler (düğme, kaydırıcı, liste, grafik, sekme) sunan ve dokunmayı kendisi yöneten açık kaynaklı bir grafik kütüphanesidir. Sürüm 9 ile TFT_eSPI desteği kütüphanenin içine geldi; böylece ekran sürücüsü için ayrı bir aktarma fonksiyonu yazmana gerek kalmaz.
- Kütüphane Yöneticisi'nden lvgl kütüphanesini kur (9.x sürümü).
- libraries/lvgl klasöründeki lv_conf_template.h dosyasını bir üst klasöre, yani lvgl klasörünün yanına lv_conf.h adıyla kopyala.
- Dosyanın başındaki #if 0 satırını #if 1 yap ve LV_USE_TFT_ESPI değerini 1 olarak değiştir.
- Daha büyük yazı tipleri istiyorsan LV_FONT_MONTSERRAT_20 gibi satırları da 1 yap; her yazı tipi flash bellekte yer kaplar.
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}Bu kodun sonuna setup() ve loop() fonksiyonlarını ekle: setup() içinde yalnız lvglSetup(), loop() içinde yalnız lvglLoop() çağrılsın. Ekran, ekranın onda biri kadar (yaklaşık 15 KB) bir tamponla parça parça çizilir; PSRAM'siz CYD için bu iyi bir dengedir. LVGL'de döndürmeyi kütüphanenin kendisi yaptığı için dokunmatik koordinatları dikey (240×320) düzende verilir ve LVGL onları yatay ekrana çevirir. Düğme aç-kapa (checkable) olarak tanımlandığı için her dokunuşta kırmızı LED'in durumu değişir; kaydırıcı ise altındaki etikete yüzde değerini yazar.
CYD proje fikirleri: hava durumu ve akıllı ev paneli
- Hava durumu ekranı: ESP32 ile hava durumu API'si kullanarak sıcaklığı, nemi ve günlük tahmini simgelerle göster.
- Akıllı ev paneli: MQTT ve Home Assistant üzerinden lambaları ve prizleri ekrandaki düğmelerle yönet.
- Masa saati: NTP ile internet saatini büyük rakamlarla göster, gece arka ışığı LDR'ye göre kıs.
- Sensör paneli: CN1'e bağladığın bir I2C sensörünün sıcaklık, nem ve basınç verilerini canlı grafikle çiz.
- Veri kaydedici: Ölçümleri microSD karta yaz, ekranda son 24 saatin grafiğini göster.
- Dokunmatik oyunlar: XOX, yılan ya da hafıza oyunlarını kalemle oynanacak şekilde tasarla.
Sık hatalar ve çözümleri
| Belirti | Olası neden | Çözüm |
|---|---|---|
| Ekran bembeyaz ya da siyah | User_Setup.h ayarlanmamış ya da yanlış sürücü | Bu yazıdaki ayarları kopyala; iki USB'li kartta ST7789 dene |
| Renkler negatif gibi | Sürücü ya da renk tersleme ayarı uymuyor | tft.invertDisplay(1) ekle ya da sürücüyü değiştir |
| Dokunmatik tepki vermiyor | Dokunmatik, ekranla aynı SPI hattında sanılmış | touchSpi(VSPI) ile 25, 32, 39, 33 pinlerini kullan |
| Dokunulan yer ile çizim kayık | Kalibrasyon değerleri karta uymuyor | Köşelerdeki ham değerleri ölçüp map() satırlarını güncelle |
| Ekranda karıncalanma ya da bozuk çizgiler | SPI hızı yüksek | SPI_FREQUENCY değerini 27000000'e düşür |
| Wi-Fi açılınca yeniden başlıyor | USB portu ya da kablo yeterli akım vermiyor | Kısa ve kaliteli kablo, en az 1 A veren adaptör kullan |
| Yükleme başlamıyor | CH340 sürücüsü yok ya da kart indirme modunda değil | Sürücüyü kur, yükleme başlarken BOOT'a bas |
ESP32 Cheap Yellow Display, ekranlı bir ESP32 projesine en kısa yoldan başlamanı sağlar: kablo karmaşası yok, lehim yok, yalnızca kod var. Ayrı modüllerle çalışmayı tercih edersen ILI9341 TFT ekran yazısı aynı sürücüyü breadboard üzerinde anlatıyor. BlueGrays uygulamasında hava durumu, NTP saati, web sunucusu ve LDR projelerini adım adım devre şemaları ve kodlarıyla bulabilir, bu fikirleri CYD'nin ekranına taşıyabilirsin.
Sıkça sorulan sorular
ESP32 Cheap Yellow Display için Arduino IDE'de hangi kart seçilir?
Kart olarak ESP32 Dev Module seçmen yeterlidir, çünkü CYD'nin üzerinde standart bir ESP32-WROOM-32 modülü vardır. Flash boyutu 4 MB kalabilir; yükleme sorun çıkarırsa hızı 115200'e düşür. Port görünmüyorsa CH340 sürücüsünü kur.
CYD ekranı neden beyaz kalıyor?
Beyaz ekran, arka ışığın yandığını ama ekran sürücüsüne doğru veri gitmediğini gösterir. Neredeyse her zaman TFT_eSPI'nin User_Setup.h dosyası CYD'ye göre ayarlanmamıştır ya da yanlış sürücü seçilmiştir. Pin ayarlarını kontrol et; iki USB girişli kartlarda ILI9341 yerine ST7789 sürücüsünü dene.
CYD'de hangi pinler boşta, sensör nereye bağlanır?
Kullanılabilir pinler CN1 konnektöründeki GPIO 22 ve 27 ile P3'teki GPIO 35'tir; 35 yalnız giriş olarak çalışır. I2C sensörleri için Wire.begin(27, 22) yazıp sensörü CN1'deki 3,3 V ve GND ile besleyebilirsin. GPIO 21 arka ışığa bağlı olduğu için başka işte kullanılmamalıdır.
CYD'de LVGL çalışır mı, bellek yeter mi?
Evet, LVGL 9 CYD'de akıcı çalışır. Kartta PSRAM olmadığı için ekranın tamamı yerine onda biri kadar (yaklaşık 15 KB) bir çizim tamponu kullanılır. Çok sayıda büyük yazı tipi ya da görsel eklersen asıl sınır flash bellek ve RAM olur; kullanmadığın yazı tiplerini lv_conf.h'te kapat.
Dokunmatik ve SD kart aynı anda kullanılabilir mi?
Kullanılabilir ama ek ayar gerekir, çünkü ikisi de ESP32'nin VSPI donanımını farklı pinlerle kullanır. En kolay yol dokunmatiği yazılımsal SPI ile okuyan bir kütüphane kullanmaktır. Diğer yol, SD karta her erişimden önce SPI hattını SD pinleriyle, sonra yeniden dokunmatik pinleriyle başlatmaktır.
CYD pil ile çalıştırılabilir mi?
Kart 5 V ile beslenir ve arka ışık ile Wi-Fi açıkken genellikle 100–250 mA çeker. Pil için bir Li-ion hücre, TP4056 şarj modülü ve 5 V'a yükselten bir dönüştürücü ya da hazır bir powerbank kullanabilirsin. Pil ömrünü uzatmak için ekranı ve Wi-Fi'yi kullanılmadığında kapatıp ESP32'yi uykuya al.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
ESP32 LDR Modülü ile Işık Şiddeti Okuma
LDR modülünün ham ADC değerini ve karanlık/aydınlık referanslarına göre hesaplanan göreli ışık yüzdesini Serial Monitor'da gerçek zamanlı izleme. Bu yüzde lux ölçümü değildir. Modülün kalibrasyon mantığını öğretir. Proje 10'un öncesinde yapılması ideal; çünkü eşik değerini belirlemek için kullanılır.

ESP32 HTTPClient + Hava Durumu API (SSD1306 OLED Ekranlı)
Bu projede ESP32 ile internet üzerinden hava durumu API'sine (wttr.in) HTTPClient.h kullanarak REST API çağrısı yapıyoruz. I2C LCD sürümünden farklı olarak burada SSD1306 OLED (128×64) ekran kullanıyoruz; büyük yazı ve vektör ikonlarla zengin bir görünüm elde ediliyor. Hava durumu için 7 vektör ikon (güneşli, yağmurlu, karlı ve diğerleri) bitmap dosyası gerekmeden çiziliyor.

ESP32 HTTPClient + Hava Durumu API (LCD Ekranlı)
Bu projede ESP32 ile internet üzerinden hava durumu API'sine (wttr.in) HTTPClient.h kullanarak REST API çağrısı yapıyoruz. ArduinoJson v7 ile gelen JSON cevabını çözümleyip şehir, sıcaklık, nem, hava durumu ve rüzgâr bilgilerini I2C LCD ekranda gösteriyoruz. wttr.in API anahtarı istemez; istediğin şehrin adını yazman yeterli.

ESP32 NTP ile İnternetten Gerçek Zaman
ESP32, Wi-Fi'a bağlanıp NTP (Network Time Protocol) sunucularından milisaniye hassasiyetiyle gerçek zamanı çeker. configTzTime() fonksiyonu sayesinde Türkiye saat dilimi (TRT, UTC+3) otomatik uygulanır; yaz/kış saati uygulayan ülkelerde DST geçişi POSIX TZ dizesiyle otomatik yönetilir. Saat hem Serial Monitor'e hem de isteğe bağlı I2C LCD'ye yazdırılır.

ESP32 Async Web Server (LCD'de IP Göstergeli)
Bu projede ESP32'yi aynı Wi-Fi ağındaki telefonunuzdan veya bilgisayarınızdan kontrol edebileceğiniz asenkron bir web sunucusuna dönüştürüyoruz. ESPAsyncWebServer kütüphanesi sayesinde sunucu birden fazla isteği aynı anda işleyebiliyor (klasik WebServer.h gibi tek istekte bloklamıyor). Tarayıcıdan ESP32'nin IP adresine bağlanıp ON/OFF butonlarına basarak (/on ve /off adresleri) GPIO 5'e bağlı LED'i açıp kapatabileceksiniz.

ESP32 Sıcaklık Loglayıcı (DHT22 + DS1307 RTC + microSD + OLED)
ESP32 ile zamanlı sıcaklık ve nem kayıt sistemi kur! Bu projede DHT22 sensörüyle dakikada bir sıcaklık ve nem okuyup DS1307 RTC modülünden aldığın gerçek zaman etiketiyle microSD karta CSV formatında kaydediyoruz. OLED ekranda büyük yazıyla son sıcaklık değeri, nem yüzdesi, zaman damgası ve toplam kayıt sayısı canlı gösterilir.

ESP32 RGB LED Kontrolü
3 ayrı LED yerine tek RGB LED ile sınırsız renk üretme. Arduino'daki gibi analogWrite() ile R/G/B değerlerini ayarlayarak gökkuşağı geçişi yaparız. Renk teorisi (red+green=yellow gibi) pratik olarak görülür.

ESP32 Buzzer ile Melodi Çalma
Pasif buzzer ile basit bir melodi (Twinkle Twinkle Little Star) çalma. Arduino'daki gibi tone() ve noTone() fonksiyonlarıyla nota çalıyoruz — ESP32 Arduino Core 3.0+ ile aynı syntax çalışır. Pasif buzzer kullanılmalı (aktif buzzer melodi çalmaz).
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

