Sensor Sentuh TTP223 dengan Arduino: Mode, Pengkabelan, dan Lampu Sentuh

Sensor sentuh TTP223 adalah modul sentuh kapasitif satu tombol yang murah; modul ini menggantikan push button mekanis dengan mendeteksi jarimu lewat perubahan kapasitansi. Modul ini hanya punya tiga pin (VCC, GND, dan I/O): ketika kamu menyentuhnya, output menjadi HIGH, dan ketika jarimu diangkat, output kembali ke LOW. Karena sesederhana itu, kamu membacanya di Arduino dengan digitalRead() persis seperti tombol, dan karena bekerja di 2–5,5 V, modul ini juga bisa langsung dihubungkan ke ESP32 atau Raspberry Pi Pico. Tanpa bagian yang bergerak, modul ini tidak aus dan tidak berbunyi klik, dan bisa disembunyikan di balik lapisan tipis plastik, kaca, atau kayu.

Di panduan ini kamu akan belajar langkah demi langkah apa yang terjadi di dalam TTP223, cara memakai jumper solder A dan B di board untuk memilih mode momentary atau toggle serta output aktif HIGH atau aktif LOW, cara membuat lampu sentuh Arduino yang menyala dan mati dengan sentuhan singkat lalu meredup dengan sentuhan panjang, cara membuat sensor bekerja di balik panel, cara memakai beberapa tombol sentuh, perbandingannya dengan pin sentuh bawaan ESP32, dan cara memakainya di Pico dengan MicroPython.

Apa itu sensor sentuh TTP223 dan bagaimana cara kerjanya?

Pad tembaga di modul dan area ground (GND) board membentuk kapasitor mungil sebesar beberapa pikofarad. Ketika jarimu mendekati pad, tubuhmu ikut menjadi bagian dari kapasitor itu dan kapasitansi totalnya naik beberapa pikofarad. Osilator sensor sekitar 1 MHz di dalam TTP223 melihat kenaikan ini sebagai perubahan frekuensi, membandingkan hasilnya dengan nilai referensi yang disimpannya, lalu mengubah output kalau selisihnya cukup besar. Rumus kapasitor pelat sejajar C = ε·A/d juga berlaku di sini: makin luas area pad (A) dan makin tipis bahan di antara jari dan pad (d), makin kuat deteksinya.

Chip ini menentukan nilai referensinya sendiri. Begitu daya diberikan, chip mengukur lingkungannya selama sekitar 0,5 detik dan mengabaikan sentuhan selama waktu itu. Setelah itu, selama tidak ada yang menyentuhnya, chip mengkalibrasi ulang dirinya kira-kira setiap 4 detik, sehingga perubahan lambat seperti suhu dan kelembapan terkompensasi seiring waktu. Karena itulah sensor menganggap apa pun yang ada di sekitar pad ketika dinyalakan sebagai “tidak disentuh”: kalau jarimu sedang menempel di pad ketika sensor dinyalakan, sensor sama sekali tidak akan melihatmu.

Pada versi TTP223-BA6 yang dipakai di modul-modul ini, beberapa opsi sudah dikunci di dalam paketnya: chip selalu berjalan dalam mode daya rendah, dan batas “maximum on time” 100 detik yang ada di paket lain dinonaktifkan. Dalam mode daya rendah chip hanya menarik beberapa mikroampere, tetapi butuh hingga sekitar 220 ms untuk merespons sentuhan pertama. Begitu sebuah sentuhan terdeteksi, chip tetap dalam mode cepat selama sekitar 12 detik dan merespons sentuhan berikutnya jauh lebih cepat. Kamu tidak akan merasakan jeda ini di lampu atau bel pintu, tetapi ingatlah hal ini kalau kamu membuat controller game yang butuh reaksi cepat.

Pinout dan pengkabelan TTP223

Karena pin output aktif mendorong sinyal ke HIGH dan LOW, kamu tidak butuh INPUT_PULLUP atau resistor eksternal di Arduino; cukup atur pin sebagai INPUT. Tidak ada pantulan kontak seperti pada tombol mekanis, karena chip hanya mengubah output-nya setelah sentuhannya stabil. Meski begitu, kalau kamu ingin kodemu menghitung satu sentuhan sebagai satu kejadian, pakai logika deteksi tepi yang kami jelaskan di Cara Menghubungkan Push Button.

Memilih mode dengan jumper solder A dan B

Di samping chip pada modul ada dua pasang pad solder kecil bertanda A dan B. Keduanya terhubung ke dua pin opsi chip: di sebagian besar modul, A memilih apakah output aktif HIGH atau aktif LOW (AHLB), dan B memilih apakah sensor bekerja dalam mode momentary atau toggle (TOG). Di dalam chip, pin-pin ini ditarik ke GND lewat resistor, jadi ketika pad terbuka opsinya bernilai “0”; jembatani kedua pad dengan setetes timah solder dan opsinya menjadi “1”. Setelah mengubah jumper, cara paling aman adalah memutus daya lalu menyambungkannya lagi. Kalau tanda di board-mu berbeda, kamu bisa dengan mudah memastikan modenya dengan LED di sketch uji pertama.

Uji pertama dengan Arduino: membaca sentuhan

1. Hubungkan pin VCC modul ke pin 5V Arduino, GND ke GND, dan pin I/O ke D2.
2. Upload sketch di bawah dan buka Serial Monitor pada 9600 baud.
3. Setelah board menyala, tunggu sekitar satu detik tanpa menyentuh pad; chip mengkalibrasi dirinya selama waktu ini.
4. Sentuh pad dengan jarimu: LED bawaan Arduino di pin 13 (dan, di sebagian besar modul, LED milik board itu sendiri) harus menyala, dan jumlah sentuhan di Serial Monitor harus bertambah satu.
5. LED tetap menyala selama jarimu ada di pad, sedangkan penghitungnya hanya bertambah sekali untuk setiap sentuhan baru.

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}

Bagian terpenting dari kode ini adalah deteksi tepi. Pembacaan sebelumnya disimpan di variabel lastState; kalau pembacaan baru bernilai HIGH dan sebelumnya LOW, itu adalah sentuhan baru. Tanpa pengecekan ini, penghitung akan bertambah di setiap putaran loop selama jarimu tetap di pad, artinya ribuan kali per detik. Jeda 600 ms di setup() memastikan chip sudah selesai kalibrasi ketika Arduino dan modul dinyalakan bersamaan. Kami memilih D2 karena pin ini salah satu pin interrupt di Uno; kalau mau, kamu juga bisa menangkap sentuhan lewat interrupt dengan attachInterrupt(digitalPinToInterrupt(2), function, RISING).

Proyek: lampu sentuh Arduino

Sekarang mari buat lampu sentuh sungguhan: sentuhan singkat menyalakan dan mematikan lampu, menahan jari di pad ketika lampu menyala akan meredupkan cahayanya perlahan, dan sentuhan panjang berikutnya membuatnya terang lagi. Karena kecerahan diatur dengan PWM, kita menghubungkan lampu ke D9, salah satu pin PWM di Uno. Untuk uji coba, LED dan resistor 220 Ω di D9 sudah cukup (pakai kalkulator resistor LED untuk mencari nilai yang tepat). Kalau kamu memakai LED strip 12 V, pasang MOSFET logic-level seperti IRLZ44N di antaranya; lihat Memakai MOSFET dengan Arduino untuk detailnya.

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}

Perhatikan bahwa tidak ada delay() di mana pun dalam kode: semua pengaturan waktu dilakukan dengan millis(), jadi loop terus berjalan dan tidak pernah melewatkan sentuhan. Kamu bisa membaca lebih lanjut tentang teknik ini di millis() vs delay(). Karena kecerahan terakhir tetap tersimpan di variabel brightness, ketika lampu dimatikan lalu dinyalakan lagi, cahayanya kembali ke level yang terakhir kamu atur, persis seperti lampu meja sentuh yang dijual di toko.

Mendeteksi sentuhan menembus bahan tipis

Fitur TTP223 yang paling populer adalah kemampuannya bekerja dari dalam kotak tanpa lubang. Plastik, akrilik, kaca, kayu, kertas, dan kain bisa dilewati medan listrik; bahan di antara pad dan jari berperan seperti dielektrik pada kapasitor. Makin tebal bahannya, makin besar d dalam rumus dan makin kecil kapasitansi antara jari dan pad; menggandakan ketebalan kira-kira membuat kapasitansi itu tinggal separuhnya. Kaca punya konstanta dielektrik lebih tinggi daripada sebagian besar plastik, jadi kaca dengan ketebalan yang sama biasanya memberi hasil lebih baik. Dalam praktiknya, modul ini biasanya bekerja baik di balik panel plastik, akrilik, atau kaca setebal 1–3 mm; panel yang lebih tebal butuh pad yang lebih besar, dan kamu harus selalu mengujinya dengan bahanmu sendiri.

• Jangan sisakan celah udara: udara punya konstanta dielektrik 1, dan celah 1 mm saja sudah sangat menurunkan sensitivitas. Tempelkan modul erat-erat ke panel, dengan sisi pad menghadap panel, memakai selotip dua sisi yang tipis atau lem.
• Perbesar pad-nya: untuk area sentuh yang lebih luas, potong elektroda dari selotip tembaga atau aluminium foil, kerok perlahan lapisan pelindung di salah satu sudut pad, lalu solder elektroda ke situ dengan kabel yang sangat pendek. Makin panjang kabelnya, makin banyak kapasitansi yang ditambahkannya dan makin tidak stabil sensornya.
• Hindari logam: panel logam, bahan yang mengandung logam, dan cat metalik mengumpulkan medan listrik pada dirinya sendiri; akibatnya sensor tidak mendeteksi apa pun atau malah terpicu sendiri.
• Turunkan sensitivitas yang berlebihan: kalau sensor terpicu sebelum jarimu mendekat, tambahkan kapasitor keramik kecil 5–20 pF (Cs) di antara pad dan GND; makin besar nilainya, makin rendah sensitivitasnya, dengan 50 pF sebagai batas atas. Kamu bisa membaca kode pada kapasitor (mis. 100 = 10 pF, 220 = 22 pF) dengan alat kode kapasitor.
• Pasang dulu, baru nyalakan: karena chip menjadikan lingkungannya sebagai referensi ketika dinyalakan, berikan daya hanya setelah panel dan tutupnya terpasang. Kalau kamu memasang panel ketika modul sedang menyala, chip bisa menganggapnya sebagai sentuhan permanen; kalau begitu, cukup putus daya lalu sambungkan lagi.

Memakai beberapa tombol sentuh

Setiap TTP223 memantau pad-nya sendiri secara independen; kalau kamu ingin empat tombol, hubungkan empat modul ke empat pin digital terpisah, dengan VCC dan GND dipakai bersama. Kalau tombolnya sangat berdekatan, jarimu juga bisa memengaruhi pad di sebelahnya; beri jarak minimal 1–2 cm antar-pad dan jauhkan modul dari kabel motor atau relay. Sketch di bawah memakai empat TTP223 dan buzzer pasif untuk membuat piano sentuh kecil: tombol mana pun yang kamu sentuh akan memainkan nadanya, dan suaranya berhenti ketika jarimu diangkat.

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}

Karena tone() hanya bisa memainkan satu nada dalam satu waktu, kode memilih tombol pertama yang disentuh dan hanya memperbarui nadanya ketika berubah, sehingga suaranya tidak berderak. Di Uno, tone() memakai Timer2, jadi analogWrite tidak bekerja di pin 3 dan 11 selama buzzer berbunyi; itu tidak masalah di sini karena piano ini hanya memakai D3 sebagai input. Ketika jumlah tombol bertambah, lebih rapi beralih ke chip multikanal daripada satu modul per tombol: TTP224 menyediakan empat tombol dengan empat output terpisah, TTP229 membaca 8 atau 16 tombol lewat antarmuka serial dua kabel, dan MPR121 memantau 12 elektroda lewat I2C.

ESP32: TTP223 atau pin sentuh bawaan?

ESP32 klasik punya sensor sentuh kapasitif bawaan, dan 10 pin (T0–T9) bisa dipakai sebagai tombol sentuh tanpa modul apa pun: berturut-turut GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33, dan 32. Fungsi touchRead() mengembalikan angka mentah; di ESP32 klasik angka ini turun ketika pin disentuh, sedangkan di ESP32-S2 dan S3 angkanya naik. ESP32-C3 sama sekali tidak punya sensor sentuh. Untuk pembahasan lengkap tentang pin bawaannya, lihat pin sentuh ESP32; tabel di bawah membandingkan kedua pendekatan ini.

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}

Ketika mulai, sketch ini mengukur nilai T0 yang belum disentuh dan memakai 70% dari nilai itu sebagai ambang; pantau nilai mentahnya di Serial Monitor (115200 baud) untuk menyetel rasionya sesuai pengkabelanmu sendiri. Kalau kamu memakai ESP32-S3, nilainya naik ketika disentuh, jadi balik perbandingannya (misalnya threshold = nilai terukur × 1.3 dan raw > threshold). Alasan lain kami menghubungkan TTP223 ke GPIO 26 adalah karena pin itu termasuk RTC GPIO: dengan esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) kamu bisa memasukkan ESP32 ke deep sleep dan membangunkannya dengan sentuhan. Karena TTP223 hanya menarik beberapa mikroampere, keduanya jadi pasangan yang hebat untuk proyek bertenaga baterai; lihat deep sleep ESP32 untuk detailnya.

TTP223 dengan Raspberry Pi Pico (MicroPython)

Chip RP2040 di Pico tidak punya sensor sentuh, jadi TTP223 adalah cara termudah untuk menambahkan tombol sentuh ke Pico. Beri daya modul dari pin 3V3(OUT) (pin fisik 36) dan hubungkan pin I/O ke GP15 (pin fisik 20). Kode MicroPython di bawah membalik status LED bawaan board di setiap sentuhan. Karena sentuhan ditangkap dengan interrupt (IRQ), tidak ada sentuhan yang terlewat meskipun loop utama sedang sibuk dengan pekerjaan lain. Kalau kamu belum tahu cara menginstal MicroPython di Pico, mulailah dari Apa Itu Raspberry Pi Pico?.

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)

Di versi MicroPython terbaru, nama Pin("LED") memilih LED bawaan di Pico maupun Pico W. Kalau kamu sudah menjembatani jumper B dan memasang modul dalam mode toggle, kamu bahkan tidak butuh interrupt: cukup tulis led.value(touch.value()) di loop, karena sekarang chip itu sendiri yang menyimpan status nyala/matinya. Meskipun output chip tidak memantul, jeda penguncian 250 ms di kode mencegah pulsa noise pendek di kabel panjang membalik LED dua kali.

Ide proyek dengan TTP223

• Lampu tidur sentuh: tambahkan LDR supaya lampu hanya merespons sentuhan ketika gelap.
• Lampu ganti warna: ubah warna cincin WS2812B NeoPixel di setiap sentuhan dan atur kecerahannya dengan sentuhan panjang.
• Kunci kode tersembunyi: pasang empat TTP223 di balik panel akrilik; menyentuh tombol dengan urutan yang benar membuat motor servo membuka kuncinya.
• Bel pintu tanpa lubang: tempelkan sensor di dalam kotak plastik; sentuhan membuat DFPlayer Mini memainkan suara bel.
• Sakelar stopkontak sentuh: nyalakan dan matikan lampu meja atau kipas angin dengan modul relay.
• Remote bertenaga baterai: biarkan ESP32 dalam deep sleep; ketika kamu menyentuh TTP223, ESP32 bangun dan mengirim perintah dengan ESP-NOW.

Kesalahan umum dan cara memperbaikinya

TTP223 adalah cara termudah untuk menambahkan antarmuka sentuh modern ke proyekmu dengan modul yang sangat murah: modul ini menggantikan tombol mekanis, bekerja di balik panel tanpa lubang, dan akur dengan semua mikrokontroler. Coba baca dulu dengan pengaturan pabrik, lalu latih deteksi tepi dan logika sentuhan panjang lewat contoh lampu dan piano. Di aplikasi BlueGrays kamu akan menemukan skema rangkaian dan kode langkah demi langkah untuk menyalakan LED dengan tombol, LED toggle nyala/mati, proyek tombol ESP32 dan Pico, serta menyalakan bohlam listrik PLN, dan kamu bisa mengubah semuanya menjadi proyek sentuh dengan memasang TTP223 sebagai pengganti tombol.