TTP223 Dokunmatik Sensör: A/B Ayarı ve Arduino Dokunmatik Lamba

TTP223 dokunmatik sensör, mekanik butonun yerine geçen, parmağının yaklaşmasını kapasitans değişiminden anlayan tek tuşlu ve çok ucuz bir kapasitif dokunmatik modüldür. Üzerinde yalnızca üç pin vardır (VCC, GND ve I/O): dokunduğunda çıkış pini HIGH olur, elini çektiğinde LOW'a döner. Bu sadelik sayesinde Arduino'da bir butonu okur gibi digitalRead() ile kullanılır ve 2–5,5 V arasında çalıştığı için ESP32 ile Raspberry Pi Pico'ya da doğrudan bağlanır. Hareketli parçası olmadığı için aşınmaz, tıklamaz ve plastik, cam ya da ahşap gibi ince bir malzemenin arkasına gizlenebilir.

Bu rehberde TTP223'ün içinde neler olup bittiğini, kartın arkasındaki A ve B lehim köprüleriyle anlık ya da kalıcı (toggle) mod ve aktif yüksek ya da aktif düşük çıkış seçmeyi, Arduino ile kısa dokunuşta yanıp uzun dokunuşta kısılan bir dokunmatik lamba yapmayı, sensörü bir panelin arkasından çalıştırmayı, birden fazla tuş kullanmayı, ESP32'nin dahili dokunmatik pinleriyle farkını ve Pico için MicroPython örneğini adım adım öğreneceksin.

TTP223 dokunmatik sensör nedir, nasıl çalışır?

Modüldeki bakır ped ile kartın toprak (GND) yüzeyi arasında birkaç pikofaradlık küçük bir kondansatör oluşur. Parmağın pede yaklaştığında vücudun da bu kondansatöre eklenir ve toplam kapasitans birkaç pikofarad artar. TTP223'ün içindeki yaklaşık 1 MHz'lik sensör osilatörü bu artışı frekans değişimi olarak algılar, sonucu kendi tuttuğu referans değerle karşılaştırır ve fark yeterince büyükse çıkışı değiştirir. Paralel plakalı kondansatör formülü C = ε·A/d burada da geçerlidir: ped alanı (A) büyüdükçe ve parmakla ped arasındaki malzeme (d) inceldikçe algılama güçlenir.

Yonga referans değerini kendisi belirler. Beslemeyi verdiğin anda yaklaşık 0,5 saniye boyunca ortamı ölçer ve bu sürede dokunuşları dikkate almaz. Sonrasında da kimse dokunmadığı sürece yaklaşık 4 saniyede bir kendini yeniden kalibre eder; böylece sıcaklık ve nem gibi yavaş değişimler zamanla telafi edilir. Bu yüzden sensör, ilk enerji verildiğinde ped hangi ortamdaysa onu "dokunulmamış" kabul eder: açılışta parmağın pedin üzerindeyse seni hiç görmez.

Modüllerde kullanılan TTP223-BA6 sürümünde bazı ayarlar kılıfın içinde sabitlenmiştir: yonga her zaman düşük güç modunda çalışır ve diğer kılıflardaki 100 saniyelik "en uzun basılı kalma" sınırı kapalıdır. Düşük güç modunda yonga yalnızca birkaç mikroamper harcar, ama ilk dokunuşa en fazla yaklaşık 220 ms içinde tepki verir. Bir dokunuş algılandıktan sonra yaklaşık 12 saniye hızlı modda kalır ve sonraki dokunuşlara çok daha çabuk yanıt verir. Lamba ya da kapı zili gibi projelerde bu gecikme fark edilmez; hızlı tepki isteyen bir oyun kumandası yapıyorsan aklında bulunsun.

TTP223 pinleri ve bağlantısı

Çıkış pini sinyali kendisi HIGH ve LOW'a sürdüğü için Arduino'da INPUT_PULLUP ya da harici bir direnç gerekmez; pini düz INPUT olarak tanımlaman yeterlidir. Mekanik butonlardaki kontak zıplaması (bounce) burada yoktur, çünkü yonga çıkışı ancak dokunuş kararlı hâle geldiğinde değiştirir. Yine de kodun bir dokunuşu tek bir olay olarak saymasını istiyorsan, buton bağlama yazısında anlattığımız kenar algılama mantığını kullanmalısın.

A ve B lehim köprüleriyle mod seçimi

Modülün üzerinde, yonganın yanında A ve B yazan iki küçük lehim pedi çifti bulunur. Bunlar yonganın iki ayar bacağına bağlıdır: çoğu modülde A, çıkışın aktif yüksek mi aktif düşük mü olacağını (AHLB), B ise sensörün anlık mı kalıcı mı çalışacağını (TOG) seçer. Yonganın içinde bu bacaklar dirençle GND'ye çekildiği için pedler açıkken ayar "0" olur; iki pedi bir damla lehimle birleştirdiğinde ayar "1"e döner. Köprüyü değiştirdikten sonra beslemeyi kesip yeniden vermek en güvenli yoldur. Kartındaki yazılar farklıysa modu ilk test kodundaki LED ile kolayca doğrulayabilirsin.

Arduino ile ilk test: dokunuşu okumak

1. Modülün VCC pinini Arduino'nun 5V pinine, GND'yi GND'ye, I/O pinini D2'ye bağla.
2. Aşağıdaki kodu yükle ve Seri Monitör'ü 9600 baud hızında aç.
3. Kart açıldıktan sonra yaklaşık bir saniye pede dokunmadan bekle; yonga bu sırada kendini kalibre eder.
4. Pede parmağınla dokun: Arduino'nun 13 numaralı pine bağlı dahili LED'i (çoğu modülde kartın kendi LED'i de) yanmalı, Seri Monitör'de dokunuş sayısı bir artmalı.
5. Parmağını pedin üzerinde tuttuğun sürece LED yanık kalır; sayaç ise her yeni dokunuşta yalnızca bir kez artar.

1const int TOUCH_PIN = 2;    // TTP223 I/O (SIG) pini / TTP223 I/O (SIG) pin
2const int LED_PIN = 13;     // Uno'nun dahili LED'i / Uno onboard LED
3
4bool lastState = false;
5unsigned long touchCount = 0;
6
7void setup() {
8  Serial.begin(9600);
9  pinMode(TOUCH_PIN, INPUT);   // çıkış push-pull, pull-up gerekmez / push-pull output, no pull-up needed
10  pinMode(LED_PIN, OUTPUT);
11  delay(600);                  // açılış kalibrasyonu bitsin (~0,5 s) / let power-on calibration finish (~0.5 s)
12}
13
14void loop() {
15  bool state = digitalRead(TOUCH_PIN) == HIGH;   // dokunurken true / true while touched
16  digitalWrite(LED_PIN, state ? HIGH : LOW);
17
18  if (state && !lastState) {   // LOW -> HIGH: yeni dokunuş / new touch
19    touchCount++;
20    Serial.print("Dokunus / Touch: ");
21    Serial.println(touchCount);
22  }
23  lastState = state;
24}

Kodun en önemli kısmı kenar algılamadır. Bir önceki okuma lastState değişkeninde saklanır; yeni okuma HIGH ve öncekisi LOW ise bu yeni bir dokunuştur. Bu kontrol olmasaydı parmağın pedde kaldığı her döngüde, yani saniyede binlerce kez, sayaç artardı. setup() içindeki 600 ms'lik bekleme, Arduino ile modül aynı anda enerjilendiğinde yonganın kalibrasyonunu bitirmesini garanti eder. D2'yi seçmemizin nedeni Uno'nun kesme (interrupt) pini olmasıdır; istersen attachInterrupt(digitalPinToInterrupt(2), fonksiyon, RISING) ile dokunuşu kesmeyle de yakalayabilirsin.

Proje: Arduino ile dokunmatik lamba

Şimdi gerçek bir dokunmatik lamba yapalım: kısa dokunuş lambayı açıp kapatsın, lamba açıkken parmağını pedde tutarsan ışık yavaşça kısılsın, bir sonraki uzun dokunuşta yeniden parlasın. Parlaklık PWM ile ayarlanacağı için lambayı Uno'nun PWM pinlerinden biri olan D9'a bağlıyoruz. Deneme için D9'a bir LED ve 220 Ω direnç yeterlidir (doğru değer için LED direnci hesaplayıcı). 12 V LED şerit kullanacaksan araya IRLZ44N gibi lojik seviyeli bir MOSFET koymalısın; ayrıntılar Arduino ile MOSFET kullanımı yazısında.

1const int TOUCH_PIN = 2;                // TTP223 I/O (fabrika ayarı: anlık, aktif yüksek) / factory default: momentary, active high
2const int LAMP_PIN = 9;                 // PWM pini: LED ya da MOSFET kapısı / PWM pin: LED or MOSFET gate
3const unsigned long LONG_PRESS = 600;   // uzun dokunuş eşiği (ms) / long-touch threshold (ms)
4
5bool lampOn = false;
6bool lastTouch = false;
7bool dimming = false;
8int brightness = 255;                   // son parlaklık (10-255) / last brightness (10-255)
9int step = 5;                           // kısma yönü ve adımı / dimming direction and step
10unsigned long touchStart = 0;
11unsigned long lastStep = 0;
12
13void setup() {
14  pinMode(TOUCH_PIN, INPUT);
15  pinMode(LAMP_PIN, OUTPUT);
16  delay(600);                           // TTP223 kalibrasyonu bitsin / let the TTP223 finish calibrating
17}
18
19void loop() {
20  bool touch = digitalRead(TOUCH_PIN) == HIGH;
21  unsigned long now = millis();
22
23  if (touch && !lastTouch) {            // dokunuş başladı / touch started
24    touchStart = now;
25    dimming = false;
26  }
27
28  if (touch && lampOn && now - touchStart > LONG_PRESS) {   // lamba açıkken uzun dokunuş / long touch while the lamp is on
29    if (!dimming) {
30      dimming = true;
31      step = -step;                     // her uzun dokunuşta yön değişir / direction flips on every long touch
32    }
33    if (now - lastStep >= 20) {         // 20 ms'de bir adım / one step every 20 ms
34      lastStep = now;
35      brightness += step;
36      if (brightness <= 10 || brightness >= 255) {
37        brightness = constrain(brightness, 10, 255);
38        step = -step;                   // uca gelince geri dön / bounce back at the ends
39      }
40      analogWrite(LAMP_PIN, brightness);
41    }
42  }
43
44  if (!touch && lastTouch && !dimming) {   // kısa dokunuş bitti: aç/kapa / short touch ended: toggle
45    lampOn = !lampOn;
46    analogWrite(LAMP_PIN, lampOn ? brightness : 0);
47  }
48
49  lastTouch = touch;
50}

Kodda hiç delay() olmadığına dikkat et: zamanlamanın tamamı millis() ile yapıldığı için döngü sürekli döner ve hiçbir dokunuşu kaçırmaz. Bu yöntemin ayrıntılarını millis() ve delay() farkı yazısında bulabilirsin. Son parlaklık brightness değişkeninde kaldığı için lambayı kapatıp açtığında ışık en son ayarladığın seviyede yanar; tıpkı mağazalardaki dokunmatik masa lambaları gibi.

İnce malzemenin arkasından algılama

TTP223'ün en sevilen özelliği, deliksiz bir kutunun içinden çalışabilmesidir. Plastik, akrilik, cam, ahşap, kâğıt ve kumaş elektrik alanını geçirir; ped ile parmağın arasındaki bu malzeme kondansatörün yalıtkanı gibi davranır. Malzeme kalınlaştıkça formüldeki d büyür ve parmakla ped arasındaki kapasitans azalır; kalınlığı iki katına çıkarmak bu kapasitansı kabaca yarıya indirir. Camın dielektrik sabiti çoğu plastikten yüksek olduğu için aynı kalınlıktaki cam genellikle daha iyi sonuç verir. Pratikte 1–3 mm'lik plastik, akrilik ya da cam panelin arkasında modül çoğu zaman sorunsuz çalışır; daha kalın panellerde pedi büyütmen gerekir ve sonucu mutlaka kendi malzemenle denemelisin.

• Hava boşluğu bırakma: Havanın dielektrik sabiti 1'dir; 1 mm'lik bir boşluk bile hassasiyeti ciddi biçimde düşürür. Modülü ped tarafı panele bakacak şekilde ince çift taraflı bantla ya da yapıştırıcıyla sıkıca yapıştır.
• Pedi büyüt: Daha büyük bir dokunma alanı için bakır bant ya da alüminyum folyodan bir elektrot kes, pedin koruyucu boyasını bir köşeden hafifçe kazı ve elektrodu çok kısa bir telle pede lehimle. Tel uzadıkça kendi kapasitansı eklenir ve sensör kararsızlaşır.
• Metal kullanma: Metal paneller, metal katkılı malzemeler ve metalik boyalar elektrik alanını kendi üzerinde toplar; sensör ya hiç algılamaz ya da kendi kendine tetiklenir.
• Fazla hassasiyeti kıs: Sensör parmak yaklaşmadan tetikleniyorsa ped ile GND arasına 5–20 pF'lık küçük bir seramik kondansatör (Cs) ekle; değer büyüdükçe hassasiyet düşer, üst sınır 50 pF'tır. Kondansatörün üzerindeki kodu (ör. 100 = 10 pF, 220 = 22 pF) kondansatör kodu aracıyla çözebilirsin.
• Önce monte et, sonra enerji ver: Yonga açılışta ortamı referans aldığı için paneli ve kapağı kapattıktan sonra beslemeyi ver. Paneli enerji varken takarsan yonga bunu sürekli bir dokunuş sanabilir; bu durumda beslemeyi kesip yeniden vermen yeterlidir.

Birden fazla dokunmatik tuş kullanmak

Her TTP223 kendi pedini bağımsız izler; dört tuş istiyorsan dört modülü dört ayrı dijital pine bağlarsın ve modüller VCC ile GND'yi ortak kullanır. Tuşlar birbirine çok yakınsa parmağın komşu pedi de etkileyebilir; pedler arasında en az 1–2 cm boşluk bırak ve modülleri motor ya da röle kablolarından uzak tut. Aşağıdaki kod dört TTP223 ve pasif bir buzzer ile küçük bir dokunmatik piyano yapar: hangi tuşa dokunursan o nota çalar, elini çekince ses kesilir.

1const int TOUCH_PINS[] = {2, 3, 4, 5};          // dört TTP223 I/O pini / four TTP223 I/O pins
2const int NOTES[]      = {262, 294, 330, 349};  // Do, Re, Mi, Fa (Hz) / C4, D4, E4, F4 (Hz)
3const int KEY_COUNT    = 4;
4const int BUZZER_PIN   = 8;                     // pasif buzzer / passive buzzer
5
6int currentNote = 0;
7
8void setup() {
9  for (int i = 0; i < KEY_COUNT; i++) {
10    pinMode(TOUCH_PINS[i], INPUT);
11  }
12  pinMode(BUZZER_PIN, OUTPUT);
13  delay(600);                                   // sensörlerin kalibrasyonu / sensor calibration
14}
15
16void loop() {
17  int note = 0;
18  for (int i = 0; i < KEY_COUNT; i++) {
19    if (digitalRead(TOUCH_PINS[i]) == HIGH) {   // ilk dokunulan tuş çalar / the first touched key plays
20      note = NOTES[i];
21      break;
22    }
23  }
24  if (note != currentNote) {                    // yalnızca nota değişince güncelle / update only when the note changes
25    currentNote = note;
26    if (note > 0) tone(BUZZER_PIN, note);
27    else noTone(BUZZER_PIN);
28  }
29}

tone() aynı anda yalnızca tek nota çalabildiği için kod dokunulan ilk tuşu seçer ve notayı yalnızca değiştiğinde günceller; böylece ses cızırdamaz. Uno'da tone() Timer2'yi kullandığından buzzer çalarken 3 ve 11 numaralı pinlerde analogWrite çalışmaz; piyanoda D3'ü yalnızca giriş olarak kullandığımız için sorun yoktur. Tuş sayısı arttıkça her biri için ayrı modül yerine çok kanallı yongalara geçmek daha düzenlidir: TTP224 dört tuşu dört ayrı çıkışla verir, TTP229 8 ya da 16 tuşu iki telli seri arayüzle okur, MPR121 ise 12 elektrotu I2C üzerinden izler.

ESP32: TTP223 mü, dahili dokunmatik pinler mi?

Klasik ESP32'nin içinde kapasitif dokunmatik algılayıcı vardır ve 10 pin (T0–T9) hiçbir modül olmadan dokunmatik tuş olarak kullanılabilir: sırasıyla GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 ve 32. touchRead() fonksiyonu ham bir sayı döndürür; klasik ESP32'de bu sayı dokunduğunda düşer, ESP32-S2 ve S3'te ise yükselir. ESP32-C3'te dokunmatik algılayıcı hiç yoktur. Dahili pinlerin ayrıntılı kullanımı için ESP32 dokunmatik pinleri yazısına bakabilirsin; aşağıdaki tablo iki yolu karşılaştırır.

1const int TTP223_PIN = 26;   // TTP223 I/O, modül 3,3 V ile beslenir / module powered from 3.3 V
2const int TOUCH_GPIO = 4;    // dahili dokunmatik T0 / built-in touch pad T0
3const int LED_PIN = 2;       // çoğu DevKit'te dahili LED / onboard LED on most DevKits
4int threshold = 0;
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(TTP223_PIN, INPUT);
9  pinMode(LED_PIN, OUTPUT);
10  delay(600);                                  // dokunmadan bekle / wait without touching
11  threshold = touchRead(TOUCH_GPIO) * 0.7;     // dokunulmamış değerin %70'i / 70% of the untouched value
12}
13
14void loop() {
15  int raw = touchRead(TOUCH_GPIO);             // klasik ESP32'de dokununca düşer / drops when touched on the classic ESP32
16  bool builtIn = raw < threshold;
17  bool module = digitalRead(TTP223_PIN) == HIGH;
18  digitalWrite(LED_PIN, (builtIn || module) ? HIGH : LOW);
19  Serial.printf("ham/raw: %d  esik/threshold: %d  T0: %d  TTP223: %d\n", raw, threshold, builtIn, module);
20  delay(100);
21}

Bu kod açılışta dokunulmamış T0 değerini ölçüp bunun %70'ini eşik olarak alır; Seri Monitör'de (115200 baud) ham değeri izleyerek oranı kendi kablona göre ayarlayabilirsin. ESP32-S3 kullanıyorsan değer dokununca yükseldiği için karşılaştırmayı tersine çevir (eşik = ölçülen değer × 1,3 ve raw > eşik gibi). TTP223'ü GPIO 26'ya bağlamamızın bir nedeni de bu pinin RTC GPIO olmasıdır: esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) ile ESP32'yi derin uykuya alıp bir dokunuşla uyandırabilirsin. TTP223 yalnızca birkaç mikroamper harcadığı için pille çalışan projelerde çok iyi bir ikili olurlar; ayrıntılar ESP32 deep sleep yazısında.

Raspberry Pi Pico ile TTP223 (MicroPython)

Pico'nun RP2040 yongasında dokunmatik algılayıcı yoktur; bu yüzden Pico'ya dokunmatik tuş eklemenin en kolay yolu TTP223'tür. Modülü 3V3(OUT) pininden (fiziksel pin 36) besle, I/O pinini GP15'e (fiziksel pin 20) bağla. Aşağıdaki MicroPython kodu her dokunuşta kartın dahili LED'ini yakıp söndürür. Dokunuşu kesmeyle (IRQ) yakaladığı için ana döngü başka işlerle meşgulken bile dokunuş kaçmaz. Pico'ya MicroPython yüklemeyi henüz bilmiyorsan Raspberry Pi Pico Nedir? yazısından başla.

1from machine import Pin
2import time
3
4touch = Pin(15, Pin.IN)            # TTP223 I/O -> GP15 (fiziksel pin 20) / physical pin 20
5led = Pin("LED", Pin.OUT)          # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6last = 0
7
8def on_touch(pin):
9    global last
10    now = time.ticks_ms()
11    if time.ticks_diff(now, last) > 250:   # bir dokunuşu bir kez say / count each touch once
12        led.toggle()
13        last = now
14
15time.sleep_ms(600)                 # TTP223 açılış kalibrasyonu / TTP223 power-on calibration
16touch.irq(trigger=Pin.IRQ_RISING, handler=on_touch)
17
18while True:
19    print("Dokunma / Touch:", touch.value(), " LED:", led.value())
20    time.sleep(1)

Güncel MicroPython sürümlerinde Pin("LED") adı hem Pico'da hem Pico W'de dahili LED'i seçer. B köprüsünü lehimleyip modülü kalıcı moda aldıysan kesmeye bile gerek kalmaz: döngüye led.value(touch.value()) yazman yeterlidir, çünkü aç/kapa durumunu artık yonganın kendisi tutar. Yonganın çıkışında zıplama olmasa da koddaki 250 ms'lik kilit, uzun kablolarda oluşabilecek kısa parazit darbelerinin LED'i iki kez değiştirmesini engeller.

TTP223 ile proje fikirleri

• Dokunmatik gece lambası: Bir LDR ekle; lamba yalnızca karanlıkta dokunuşa yanıt versin.
• Renk değiştiren lamba: Her dokunuşta bir WS2812B NeoPixel halkanın rengini değiştir, uzun dokunuşta parlaklığı ayarla.
• Gizli şifreli kilit: Akrilik bir panelin arkasına dört TTP223 yerleştir; tuşlara doğru sırayla dokununca bir servo motor kilidi açsın.
• Deliksiz kapı zili: Sensörü plastik bir kutunun içine yapıştır; dokununca DFPlayer Mini zil sesi çalsın.
• Dokunmatik priz anahtarı: Bir röle modülü ile masa lambasını ya da vantilatörü aç/kapa.
• Pille çalışan kumanda: ESP32'yi derin uykuda tut; TTP223'e dokununca uyanıp ESP-NOW ile komut göndersin.

Sık yapılan hatalar ve çözümleri

TTP223, çok ucuz bir modülle projelerine modern bir dokunmatik arayüz eklemenin en kolay yoludur: mekanik butonun yerini alır, deliksiz panellerin arkasında çalışır ve her mikrodenetleyiciyle anlaşır. Önce fabrika ayarında okumayı dene, sonra lamba ve piyano örnekleriyle kenar algılama ve uzun dokunuş mantığını pekiştir. BlueGrays uygulamasında buton ile LED yakma, aç/kapa LED, ESP32 ve Pico buton projeleri ile 220 V ampul kontrolünü adım adım devre şeması ve kodlarıyla bulabilir, butonun yerine TTP223 takarak aynı projeleri dokunmatik hâle getirebilirsin.