Parçalar · 7 dk okuma

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.

ILI9341 sürücülü 2,8 inç TFT ekran modülü
Ayrı satılan ILI9341 TFT modülü: CYD'deki 2,8 inç ekran da aynı sürücüyü kullanır; farkı, ESP32'nin ve dokunmatik devresinin aynı karta yerleştirilmiş olmasıdır.

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.

ÖzellikDeğer
İşlemci modülüESP32-WROOM-32 (çift çekirdek, 240 MHz)
Bellek520 KB SRAM, 4 MB flash, PSRAM yok
Ekran2,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)
DokunmatikDirençli panel, XPT2046 denetleyici
DepolamamicroSD kart yuvası (SPI)
Ek donanımRGB LED, LDR ışık sensörü, hoparlör çıkışı (SC8002B yükselteç)
USB ve beslememicro-USB, CH340 USB-seri yonga, 5 V
DüğmelerBOOT (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.

KartEkranNasıl tanınırDikkat
ESP32-2432S028R (tek USB)2,8" 240×320, ILI9341Yalnı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 ST7789micro-USB ve USB-C birlikteRenkler ters görünebilir; sürücü ya da invertDisplay ayarı gerekir
ESP32-2432S0242,4" 240×320Daha küçük ekranPinler ve dokunmatik yongası farklı olabilir
ESP32-2432S0323,2" 240×320Daha büyük kartKapasitif sürümde dokunmatik I2C ile okunur
ESP32-3248S0353,5" 320×480, ST7796Daha yüksek çözünürlükAyrı bir TFT_eSPI ayarı gerekir
İki USB girişli (micro-USB + USB-C) CYD'lerde ekran çoğunlukla ST7789 sürücülüdür. ILI9341 ayarıyla ekran açılsa bile renkler negatif gibi görünür: siyah yerine beyaz, mavi yerine sarı. Bu durumda User_Setup.h'te ST7789_DRIVER'ı seç ya da tft.init() satırından sonra tft.invertDisplay(1) ekle.

CYD pin tablosu

ParçaSinyal ve GPIONot
Ekran (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2HSPI hattı; RST ucu EN'e bağlı
Arka ışıkGPIO 21HIGH = açık; PWM ile kısılabilir
Dokunmatik (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36VSPI hattı, ekrandan ayrı
microSDSCK 18, MISO 19, MOSI 23, CS 5VSPI'nin varsayılan pinleri
RGB LEDKırmızı 4, yeşil 16, mavi 17Ortak anot: LOW = yanar
LDR ışık sensörüGPIO 34Yalnız giriş, analogRead ile okunur
HoparlörGPIO 26SC8002B yükselteç, SPEAK konnektörü
BOOT düğmesiGPIO 0Programda düğme olarak da okunabilir
Seri port (P1)TX 1, RX 3USB-seri yongayla ortak
Boş pinlerGPIO 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.

P3 konnektöründeki GPIO 21 aynı zamanda ekranın arka ışığını sürer; buraya bir şey bağlayıp pini LOW yaparsan ekran kararır. GPIO 35 ise yalnız giriş olarak çalışır, LED ya da röle süremez. Harici bir parçayı CN1'deki 3,3 V ucundan beslerken yüzlerce miliamper çekme; kart zaten ekran ve Wi-Fi için önemli bir akım harcıyor.

Arduino IDE kurulumu: kart ayarı ve kütüphaneler

  1. Arduino IDE'ye ESP32 kart paketini kur (Kart Yöneticisi'nde esp32 by Espressif) ve kart olarak ESP32 Dev Module seç.
  2. 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.
  3. Kütüphane Yöneticisi'nden TFT_eSPI (Bodmer) ve XPT2046_Touchscreen (Paul Stoffregen) kütüphanelerini kur.
  4. TFT_eSPI klasöründeki User_Setup.h dosyasının içeriğini bir sonraki bölümdeki ayarlarla değiştir.
  5. 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.

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

İlk test: ekrana yazı ve dokunmatikle çizim

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}

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.

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}

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.

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}
Dokunmatik denetleyici de SD kart da VSPI donanımını kullanır, ama farklı pinlerle. İkisini aynı programda kullanmak istiyorsan dokunmatiği yazılımsal SPI ile okuyan bir kütüphane (ör. XPT2046_Bitbang) seç ya da SD işlemlerinden önce ve sonra SPI hattını ilgili pinlerle yeniden başlat. Aksi hâlde biri çalışırken diğeri susar.

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.

  1. Kütüphane Yöneticisi'nden lvgl kütüphanesini kur (9.x sürümü).
  2. 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.
  3. Dosyanın başındaki #if 0 satırını #if 1 yap ve LV_USE_TFT_ESPI değerini 1 olarak değiştir.
  4. Daha büyük yazı tipleri istiyorsan LV_FONT_MONTSERRAT_20 gibi satırları da 1 yap; her yazı tipi flash bellekte yer kaplar.
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}

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

BelirtiOlası nedenÇözüm
Ekran bembeyaz ya da siyahUser_Setup.h ayarlanmamış ya da yanlış sürücüBu yazıdaki ayarları kopyala; iki USB'li kartta ST7789 dene
Renkler negatif gibiSürücü ya da renk tersleme ayarı uymuyortft.invertDisplay(1) ekle ya da sürücüyü değiştir
Dokunmatik tepki vermiyorDokunmatik, ekranla aynı SPI hattında sanılmıştouchSpi(VSPI) ile 25, 32, 39, 33 pinlerini kullan
Dokunulan yer ile çizim kayıkKalibrasyon değerleri karta uymuyorKöşelerdeki ham değerleri ölçüp map() satırlarını güncelle
Ekranda karıncalanma ya da bozuk çizgilerSPI hızı yüksekSPI_FREQUENCY değerini 27000000'e düşür
Wi-Fi açılınca yeniden başlıyorUSB portu ya da kablo yeterli akım vermiyorKısa ve kaliteli kablo, en az 1 A veren adaptör kullan
Yükleme başlamıyorCH340 sürücüsü yok ya da kart indirme modunda değilSürücüyü kur, yükleme başlarken BOOT'a bas
Wi-Fi'ye bağlanırken kart sürekli yeniden başlıyor ve Seri Monitör'de "Brownout detector was triggered" yazıyorsa sorun koddan değil beslemeden kaynaklanır; ayrıntılar ESP32 brownout ve Guru Meditation hataları yazısında.

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.

Tüm projeleri gör
ESP32 LDR Modülü ile Işık Şiddeti Okuma
ES-11Başlangıç

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.

4.6(36)
55
ESP32 HTTPClient + Hava Durumu API (SSD1306 OLED Ekranlı)
ES-32İleri
Premium

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.

4.3(10)
22
ESP32 HTTPClient + Hava Durumu API (LCD Ekranlı)
ES-31İleri
Premium

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.

4.7(13)
20
ESP32 NTP ile İnternetten Gerçek Zaman
ES-26İleri
Premium

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.

4.5(13)
22
ESP32 Async Web Server (LCD'de IP Göstergeli)
ES-27İleri

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.

4.8(16)
26
ESP32 Sıcaklık Loglayıcı (DHT22 + DS1307 RTC + microSD + OLED)
ES-40İleri
Premium

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.

4.7(7)
12
ESP32 RGB LED Kontrolü
ES-9Başlangıç

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.

4.6(29)
52
ESP32 Buzzer ile Melodi Çalma
ES-12Başlangıç
Premium

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

4.8(30)
55