ESP32 Touch Pin Kullanımı: touchRead, Eşik Değeri ve Kaydırıcı

ESP32 touch pinleri, kartın içinde hazır bulunan kapasitif dokunmatik algılayıcılara bağlı özel GPIO'lardır. Klasik ESP32'de 10 tane vardır (T0–T9) ve hiçbir ek modül gerektirmeden bir kabloya, alüminyum folyoya ya da bakır banda dokunduğunu algılar. Bunun için tek bir fonksiyon yeter: touchRead(). Parmağın ped yaklaştığında devreye küçük bir kapasite ekler, ESP32 de bu değişimi bir sayı olarak sana verir. Böylece mekanik buton koymadan dokunmatik anahtar, ışık dimmeri, kaydırıcı ya da gizli bir açma tuşu yapabilirsin.

Bu rehberde önce hangi GPIO'nun hangi dokunmatik kanala bağlı olduğunu ve hangilerinden uzak durman gerektiğini göreceğiz. Ardından touchRead değerlerini okuyup doğru eşiği belirleyecek, otomatik kalibrasyon ve histerezisle sağlam bir dokunmatik buton yazacağız. Folyo ve bakır bantla ped yapmayı, üç pedli bir kaydırıcıyla LED parlaklığını ayarlamayı, touchAttachInterrupt ile kesme kullanmayı ve ESP32'yi dokunarak deep sleep'ten uyandırmayı da öğreneceksin. Son bölümlerde nem ve parazit sorunlarını, ESP32-S3'ün farklarını ve kısa bir MicroPython örneğini bulacaksın.

ESP32 dokunmatik pinleri nasıl çalışır?

Her dokunmatik pin, içerideki bir ölçüm devresine bağlıdır. Bu devre pini sürekli şarj edip boşaltır ve belirli bir sürede kaç şarj-deşarj döngüsü tamamlandığını sayar. Pine bağlı kablo ve ped küçük bir kondansatör gibi davranır. Parmağını yaklaştırdığında vücudun bu kondansatöre birkaç pikofarad ekler, şarj ve deşarj yavaşlar, aynı sürede tamamlanan döngü sayısı azalır. Klasik ESP32'de bu yüzden dokununca touchRead değeri düşer. Kısa bir kabloyla boşta genellikle 40–80 arası bir değer görürsün; parmakla dokunduğunda değer 10–25 civarına iner. Bu sayılar kablo uzunluğuna, ped boyutuna, karta ve ortama göre değişir; bu yüzden eşik değerini hiçbir zaman ezbere yazma, kendi düzeneğinde ölç.

ESP32 touch pin tablosu (T0–T9)

Dokunmatik kanallar yalnız belirli GPIO'lara bağlıdır; başka bir pine touchRead uygularsan anlamlı değer alamazsın. Arduino çekirdeği bu kanallar için T0, T1 gibi hazır sabitler tanımlar, yani kodda touchRead(T0) yazmakla touchRead(4) yazmak aynıdır. Bazı pinler açılışta kartın nasıl başlayacağını belirleyen strapping pinleridir; bunlar dokunmatik olarak çalışır ama ilk tercihin olmamalı.

Ped yapmak: kablo, alüminyum folyo ve bakır bant

Dokunmatik ped olarak iletken her yüzey işe yarar. En basiti, pine takılı bir jumper kablonun açık ucudur. Daha rahat bir yüzey için 2×2 cm'lik bir alüminyum folyo ya da yapışkanlı bakır bant kullanabilirsin; bakır bant lehim de tuttuğu için kalıcı projelerde daha iyidir. Pedi kartona, plastik kutunun iç yüzüne ya da bir ahşap parçanın arkasına yapıştırabilirsin. 1–3 mm'lik plastik, akrilik ya da cam üzerinden de dokunma algılanır; yalnızca değerdeki düşüş azalır, bu yüzden eşiği yeniden ölçmen gerekir. Pedi ESP32'ye bağlayan kabloyu kısa tut: 20–30 cm'yi aşan kablolar antene dönüşür, kablonun kendisine dokunmak da tetikleme yapar.

touchRead değerlerini okumak ve eşik belirlemek

İlk iş, kendi düzeneğindeki gerçek sayıları görmek. Aşağıdaki kod GPIO 4 (T0) ve GPIO 27 (T7) pinlerini sekizer kez okuyup ortalamasını yazar. Arduino IDE'de Araçlar menüsünden Seri Çizici'yi açarsan iki çizgiyi canlı izleyebilir, dokunduğunda değerlerin nasıl düştüğünü görebilirsin.

1// ESP32 dokunmatik değer okuma / ESP32 touch value reading
2// GPIO 4 = T0, GPIO 27 = T7
3
4void setup() {
5  Serial.begin(115200);
6  delay(500);
7}
8
9void loop() {
10  uint32_t t0 = 0, t7 = 0;
11  for (int i = 0; i < 8; i++) {      // 8 ölçümün ortalaması / average of 8 readings
12    t0 += touchRead(T0);
13    t7 += touchRead(T7);
14  }
15  Serial.print("T0:");
16  Serial.print(t0 / 8);
17  Serial.print(" T7:");
18  Serial.println(t7 / 8);            // Seri Çizici için / for the Serial Plotter
19  delay(100);
20}

Değerleri izlerken üç durumu not et: ped boştayken, parmak pede değerken ve parmak pedin 1–2 cm yakınındayken. Örneğin boşta 62, dokununca 14, yaklaşınca 45 okuyorsan, güvenli eşik boştaki değerin yaklaşık yüzde 60'ıdır, yani 37 civarı. Eşiği boştaki değere çok yakın koyarsan parmak yaklaşınca bile tetiklenir; çok aşağı koyarsan hafif dokunuşları kaçırırsın.

Otomatik kalibrasyonlu dokunmatik buton

Sabit bir eşik sayısı yazmak yerine, kart açıldığında pedin boştaki değerini ölçüp eşiği ondan hesaplamak çok daha güvenilirdir. Aşağıdaki kod açılışta 50 ölçümün ortalamasını alır, değer yüzde 40 düştüğünde dokunma kabul eder ve LED'i değiştirir. Bırakmayı ise değer boştaki değerin yüzde 80'inin üstüne çıkınca kabul eder. İki ayrı eşik kullanmaya histerezis denir; değer tam sınırdayken titreyip art arda tetiklemeyi önler. Buton mantığının mekanik buton tarafını merak ediyorsan buton nasıl bağlanır yazısına bakabilirsin.

1// Otomatik kalibrasyonlu dokunmatik buton / self-calibrating touch button
2// GPIO 4 (T0) dokunma pedi, GPIO 2 kart üstü LED
3// GPIO 4 (T0) touch pad, GPIO 2 onboard LED
4
5const uint8_t DOKUNMA_PIN = T0;   // GPIO 4
6const uint8_t LED_PIN = 2;
7
8uint32_t bosDeger = 0;            // dokunulmamış değer / untouched value
9uint32_t basEsik, birakEsik;      // histerezisli eşikler / thresholds with hysteresis
10bool basili = false;
11bool ledDurum = false;
12
13uint32_t ortalamaOku(uint8_t pin, int adet) {
14  uint32_t toplam = 0;
15  for (int i = 0; i < adet; i++) {
16    toplam += touchRead(pin);
17    delay(2);
18  }
19  return toplam / adet;
20}
21
22void setup() {
23  Serial.begin(115200);
24  pinMode(LED_PIN, OUTPUT);
25  delay(300);                                  // açılışta pede dokunma / do not touch at boot
26  bosDeger = ortalamaOku(DOKUNMA_PIN, 50);
27  basEsik = bosDeger * 60 / 100;               // %40 düşüş = dokunma / 40% drop = touch
28  birakEsik = bosDeger * 80 / 100;             // %20 altına dönünce bırakıldı / released
29  Serial.printf("Bos: %u  Bas: %u  Birak: %u\n", bosDeger, basEsik, birakEsik);
30}
31
32void loop() {
33  uint32_t deger = ortalamaOku(DOKUNMA_PIN, 4);
34
35  if (!basili && deger < basEsik) {            // yeni dokunma / new touch
36    basili = true;
37    ledDurum = !ledDurum;
38    digitalWrite(LED_PIN, ledDurum);
39    Serial.println("Dokunuldu / touched");
40  } else if (basili && deger > birakEsik) {    // parmak çekildi / finger lifted
41    basili = false;
42  }
43  delay(20);
44}

touchAttachInterrupt ile dokunma kesmesi

Sürekli touchRead çağırmak yerine dokunmatik donanımın arka planda ölçüm yapmasını ve değer eşiğin altına inince bir fonksiyonu çağırmasını isteyebilirsin. Bunun için touchAttachInterrupt(pin, fonksiyon, eşik) kullanılır. Klasik ESP32'de kesme, ölçülen değer eşiğin altına indiğinde tetiklenir ve parmak pedde kaldıkça her ölçüm döngüsünde yeniden gelir. Bu yüzden kesme fonksiyonunda yalnızca bir bayrak kurup asıl işi loop() içinde, zaman kontrolüyle yapmak gerekir. Kesmelerin genel kurallarını Arduino interrupt yazısında anlattık.

1// touchAttachInterrupt ile dokunma kesmesi / touch interrupt
2// GPIO 27 (T7) pedi; eşik touchRead ile ölçülerek seçilmeli
3// GPIO 27 (T7) pad; pick the threshold from your touchRead values
4
5const uint8_t PED = T7;            // GPIO 27
6const uint16_t ESIK = 40;          // ESP32: değer bunun ALTINA inince tetikler / fires below this
7volatile bool dokunuldu = false;
8
9void IRAM_ATTR dokunmaKesmesi() {
10  dokunuldu = true;                // kesmede yalnız bayrak / only set a flag in the ISR
11}
12
13void setup() {
14  Serial.begin(115200);
15  touchAttachInterrupt(PED, dokunmaKesmesi, ESIK);
16}
17
18void loop() {
19  static unsigned long sonDokunma = 0;
20  if (dokunuldu) {
21    dokunuldu = false;
22    // Parmak durdukça kesme tekrar tekrar gelir; 300 ms'de bir say
23    // The ISR repeats while the finger stays; count once per 300 ms
24    if (millis() - sonDokunma > 300) {
25      sonDokunma = millis();
26      Serial.printf("Dokunma! deger: %u\n", touchRead(PED));
27    }
28  }
29}

Bu örnekte eşik 40 olarak yazıldı; kendi pedinde boşta 60 civarı okuyorsan uygundur, değilse önceki ölçüm kodundaki sayılara göre değiştir. Kesme fonksiyonundaki IRAM_ATTR ifadesi fonksiyonu hızlı belleğe yerleştirir; ESP32'de kesme fonksiyonlarında kullanılması önerilir. Kesmeyi kapatmak için touchDetachInterrupt(pin) çağırabilirsin. Klasik ESP32'de touchInterruptSetThresholdDirection(false) ile kesmenin değer eşiğin üstüne çıkınca tetiklenmesini de sağlayabilirsin; bu, parmağın çekildiği anı yakalamak için kullanışlıdır.

Üç pedli dokunmatik kaydırıcı (slider)

Yan yana dizilmiş üç ped, parmağın konumunu bulmana yeter. Parmak iki pedin arasındayken ikisinin de değeri düşer; hangi pedde ne kadar düşüş olduğuna bakarak ağırlıklı ortalama ile konumu hesaplarsın. Pedleri düz kare yerine iç içe geçen zikzak ya da ok ucu biçiminde kesersen, parmak her konumda en az iki pede değer ve kaydırıcı çok daha akıcı çalışır. Bakır banttan 1,5 cm genişliğinde, aralarında 1–2 mm boşluk olan üç şerit kesmek iyi bir başlangıçtır.

1// Üç pedli dokunmatik kaydırıcı ile LED parlaklığı / 3-pad touch slider dims an LED
2// Pedler: GPIO 13 (T4), GPIO 14 (T6), GPIO 33 (T8); LED: GPIO 26
3// Pads: GPIO 13 (T4), GPIO 14 (T6), GPIO 33 (T8); LED: GPIO 26
4
5const uint8_t pedler[3] = {T4, T6, T8};
6const uint8_t LED_PIN = 26;
7uint32_t bos[3];                   // her pedin boştaki değeri / idle value of each pad
8int parlaklik = 0;
9
10uint32_t oku(uint8_t pin) {
11  uint32_t t = 0;
12  for (int i = 0; i < 4; i++) t += touchRead(pin);
13  return t / 4;
14}
15
16void setup() {
17  Serial.begin(115200);
18  delay(300);
19  for (int p = 0; p < 3; p++) {
20    uint32_t t = 0;
21    for (int i = 0; i < 32; i++) t += touchRead(pedler[p]);
22    bos[p] = t / 32;
23  }
24}
25
26void loop() {
27  long fark[3];
28  long toplam = 0;
29  for (int p = 0; p < 3; p++) {
30    fark[p] = (long)bos[p] - (long)oku(pedler[p]);   // dokununca değer düşer / value drops on touch
31    if (fark[p] < 0) fark[p] = 0;
32    toplam += fark[p];
33  }
34
35  // Toplam düşüş boştaki değerin %25'ini geçerse parmak var
36  // A finger is present if the total drop exceeds 25% of an idle value
37  if (toplam > (long)bos[1] / 4) {
38    // Ağırlıklı ortalama: ped A = 0, ped B = 500, ped C = 1000
39    // Weighted average: pad A = 0, pad B = 500, pad C = 1000
40    long konum = (fark[1] * 500L + fark[2] * 1000L) / toplam;
41    parlaklik = map(konum, 0, 1000, 0, 255);
42    analogWrite(LED_PIN, parlaklik);
43    Serial.printf("Konum: %ld  Parlaklik: %d\n", konum, parlaklik);
44  }
45  delay(30);
46}

Kod açılışta her pedin boştaki değerini kaydeder, sonra her döngüde düşüş miktarlarını hesaplar. Toplam düşüş yeterince büyükse parmak kaydırıcının üzerindedir ve konum 0 ile 1000 arasında bulunur. Bu değeri map() ile 0–255 aralığına çevirip analogWrite() ile LED'e veriyoruz. analogWrite(), ESP32 Arduino çekirdeğinin hem 2.x hem 3.x sürümlerinde çalışır. PWM'in nasıl çalıştığını PWM nedir yazısında bulabilirsin.

Dokunarak deep sleep'ten uyanma

Pille çalışan bir projede ESP32'yi deep sleep'e sokup yalnızca biri pede dokunduğunda uyandırabilirsin. Bu modda kartın çekirdekleri kapalıdır ama dokunmatik ölçüm devresi düşük güçle çalışmaya devam eder. touchSleepWakeUpEnable(pin, eşik) fonksiyonu hem eşiği ayarlar hem de dokunmatik uyandırmayı açar. Klasik ESP32'de birden fazla pedi uyandırma kaynağı yapabilirsin; ESP32-S2 ve S3'te yalnız bir ped kullanılabilir. Uyandıktan sonra esp_sleep_get_touchpad_wakeup_status() hangi pedin uyandırdığını söyler. Deep sleep'in ayrıntılarını ve akım değerlerini ESP32 deep sleep yazısında anlattık.

1// Dokunarak deep sleep'ten uyanma / wake from deep sleep by touch
2// GPIO 27 (T7) pedi / GPIO 27 (T7) pad
3
4#if CONFIG_IDF_TARGET_ESP32
5  #define ESIK 40      // ESP32: değer bunun altına inerse uyanır / wakes below this value
6#else
7  #define ESIK 5000    // ESP32-S2/S3: boştaki değere göre artış / rise above the baseline
8#endif
9
10RTC_DATA_ATTR int uyanmaSayisi = 0;   // uykuda korunur / kept during deep sleep
11
12void setup() {
13  Serial.begin(115200);
14  delay(500);
15  uyanmaSayisi++;
16
17  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_TOUCHPAD) {
18    Serial.printf("Dokunmayla uyandi, ped: %d\n", (int)esp_sleep_get_touchpad_wakeup_status());
19  } else {
20    Serial.println("Ilk acilis ya da baska neden / first boot or other cause");
21  }
22  Serial.printf("Uyanma sayisi: %d\n", uyanmaSayisi);
23
24  // Burada ölçüm yap, veri gönder... / take readings, send data here...
25  delay(2000);
26
27  touchSleepWakeUpEnable(T7, ESIK);   // T7 pedini uyandırma kaynağı yap / enable T7 as wake source
28  Serial.println("Uyuyorum / going to sleep");
29  Serial.flush();
30  esp_deep_sleep_start();
31}
32
33void loop() {
34}

Uyandıktan sonra kod setup()'tan yeniden başlar, çünkü deep sleep'te RAM'in içeriği silinir. Uyanma sayısını korumak için değişkenin önüne RTC_DATA_ATTR yazdık; bu değişkenler uyku boyunca korunan küçük RTC belleğinde saklanır. Dokunmatik ölçüm uykudayken de sürdüğü için deep sleep akımı zamanlayıcıyla uyanmaya göre biraz daha yüksek olur; pil ömrünü hesaplarken bunu hesaba kat. Koddaki #if bloğu aynı programın ESP32-S2 ve S3'te de doğru eşikle derlenmesini sağlar.

ESP32 MicroPython ile dokunmatik pin

ESP32'ye MicroPython yüklediysen aynı işi machine modülündeki TouchPad sınıfıyla yaparsın. read() metodu Arduino'daki touchRead() ile aynı değeri döndürür; klasik ESP32'de yine dokununca düşer. Uyandırma için de esp32.wake_on_touch(True) ve pedin config(eşik) metodu kullanılır.

1# ESP32 MicroPython dokunmatik pin / ESP32 MicroPython touch pin
2from machine import Pin, TouchPad
3import time
4
5ped = TouchPad(Pin(4))       # GPIO 4 = T0
6led = Pin(2, Pin.OUT)        # kart üstü LED / onboard LED
7
8bos = sum(ped.read() for _ in range(20)) // 20   # dokunulmamış değer / idle value
9esik = bos * 6 // 10
10basili = False
11
12while True:
13    deger = ped.read()
14    if not basili and deger < esik:
15        basili = True
16        led.value(not led.value())   # her dokunuşta LED'i değiştir / toggle on every touch
17        print("dokunuldu", deger)
18    elif basili and deger > bos * 8 // 10:
19        basili = False
20    time.sleep_ms(30)

Raspberry Pi Pico'da dahili kapasitif dokunmatik algılayıcı yoktur. Pico ya da Arduino Uno ile dokunmatik buton istiyorsan en kolay çözüm hazır bir TTP223 modülüdür; modül dokunmayı kendi içinde algılar ve sana sıradan bir dijital sinyal verir.

Nem, su ve parazit sorunları

Kapasitif algılama, parmağın yanında suyu da algılar. Pedin üzerindeki bir su damlası ya da yoğun nem kapasiteyi artırır, değer düşer ve buton kendiliğinden tetiklenebilir. Banyo, mutfak ya da dış mekân projelerinde pedi su tutmayan bir yüzeyin arkasına yerleştir, eşiği biraz daha düşük seç ve dokunmanın en az 50–100 ms sürmesini şart koş. Uzun kablolar, yakındaki röle ve motorlar ve kötü bir USB güç kaynağı da değerleri dalgalandırır. Aşağıdaki tablo en sık sorunları ve çözümlerini özetliyor.

ESP32-S3 ve diğer modellerde dokunmatik pin

ESP32-S2 ve ESP32-S3, ikinci nesil dokunmatik donanım kullanır ve klasik ESP32'den üç önemli noktada ayrılır. Birincisi, kanallar GPIO 1–14 üzerindedir ve 14 tanedir; T1 GPIO 1, T14 GPIO 14'tür. İkincisi, değerler çok daha büyüktür ve dokununca yükselir; boşta 20 000 civarı okuyan bir ped dokununca 40 000'in üstüne çıkabilir. Üçüncüsü, touchAttachInterrupt ve touchSleepWakeUpEnable fonksiyonlarındaki eşik mutlak bir değer değil, boştaki değere göre artış miktarıdır. S3'te ayrıca touchInterruptGetLastStatus(pin) ile pedin hâlâ basılı olup olmadığını öğrenebilirsin. ESP32-C3 ve ESP32-C6'da ise dokunmatik algılayıcı bulunmaz. Kodunu birden fazla model için yazıyorsan, uyandırma örneğindeki gibi CONFIG_IDF_TARGET_ESP32 ile ayrım yap.

Dokunmatik pinlerle proje fikirleri

• Masa lambası: ahşap bir kapağın arkasına yapıştırılmış bakır bant ile görünmez açma kapama düğmesi, uzun dokunuşla parlaklık ayarı.
• Kaydırıcılı dimmer: üç pedli kaydırıcıyla WS2812B LED şeridinin parlaklığını ve rengini değiştirmek.
• Pille çalışan kapı zili ya da not cihazı: ESP32 deep sleep'te bekler, pede dokunulunca uyanıp Wi-Fi ile bildirim gönderir.
• Meyve piyanosu: muz ve elmalara bağlanan kablolarla her meyvede farklı nota çalan bir oyuncak; ses için buzzer kullanılabilir.
• Gizli şifre paneli: kutunun içine yerleştirilmiş dört ped ile doğru sırayla dokunulduğunda açılan bir kilit.

ESP32'nin dokunmatik pinleri, birkaç santimlik folyo ve birkaç satır kodla projene dokunmatik arayüz kazandırır. BlueGrays uygulamasında ESP32 ile LED yakma, buton ile LED kontrolü, PWM ile LED parlaklığı ve deep sleep gibi projeleri devre şeması ve koduyla adım adım bulabilir, butonların yerine bu rehberdeki dokunmatik pedleri koyarak kendi sürümünü yapabilirsin.