Pin Sentuh ESP32: touchRead, Ambang, Interrupt, dan Slider

Pin sentuh ESP32 adalah GPIO khusus yang terhubung ke sensor sentuh kapasitif yang sudah ada di dalam chip. ESP32 klasik punya 10 pin seperti ini (T0–T9), dan pin-pin ini bisa mendeteksi sentuhan pada kabel, potongan aluminium foil, atau pita tembaga tanpa modul tambahan. Cukup satu fungsi: touchRead(). Ketika jarimu mendekati pad, jarimu menambahkan sedikit kapasitansi ke rangkaian, lalu ESP32 memberikan perubahan itu kepadamu dalam bentuk angka. Dengan begitu kamu bisa membuat sakelar sentuh, dimmer lampu, slider, atau tombol buka tersembunyi tanpa push button mekanis.

Di panduan ini kita akan melihat dulu GPIO mana yang terhubung ke kanal sentuh mana, dan mana yang sebaiknya dihindari. Lalu kita akan membaca nilai touchRead, memilih ambang yang tepat, dan menulis tombol sentuh yang andal dengan kalibrasi otomatis dan histeresis. Kamu juga akan belajar membuat pad dari foil dan pita tembaga, mengatur kecerahan LED dengan slider tiga pad, memakai interrupt dengan touchAttachInterrupt, dan membangunkan ESP32 dari deep sleep dengan sentuhan. Bagian akhir membahas masalah kelembapan dan derau, perbedaan ESP32-S3, serta contoh singkat MicroPython.

Bagaimana cara kerja pin sentuh ESP32?

Setiap pin sentuh terhubung ke rangkaian pengukur di dalam chip. Rangkaian ini terus mengisi dan mengosongkan pin, lalu menghitung berapa banyak siklus pengisian-pengosongan yang selesai dalam waktu tertentu. Kabel dan pad di pin itu berperilaku seperti kapasitor kecil. Ketika kamu mendekatkan jari, tubuhmu menambahkan beberapa pikofarad ke kapasitor itu, pengisian dan pengosongan jadi lebih lambat, dan siklus yang selesai dalam waktu yang sama jadi lebih sedikit. Itu sebabnya di ESP32 klasik nilai touchRead turun ketika disentuh. Dengan kabel pendek, biasanya kamu akan melihat 40–80 ketika tidak disentuh; ketika disentuh jari, nilainya turun ke sekitar 10–25. Angka-angka ini bergantung pada panjang kabel, ukuran pad, board, dan lingkungan, jadi jangan pernah menulis ambang di kode dari hafalan: ukur di rangkaianmu sendiri.

Tabel pin sentuh ESP32 (T0–T9)

Kanal sentuh hanya terhubung ke GPIO tertentu; kalau kamu memakai touchRead di pin lain, kamu tidak akan mendapat nilai yang berarti. Core Arduino sudah mendefinisikan konstanta seperti T0 dan T1 untuk kanal-kanal ini, jadi menulis touchRead(T0) di kode sama dengan touchRead(4). Beberapa pin ini adalah pin strapping yang menentukan cara board mulai ketika boot; pin-pin itu tetap bisa dipakai sebagai pin sentuh, tapi sebaiknya bukan pilihan pertamamu.

Membuat pad: kabel, aluminium foil, dan pita tembaga

Permukaan konduktif apa pun bisa dipakai sebagai pad sentuh. Yang paling sederhana adalah ujung terbuka kabel jumper yang dicolokkan ke pin. Untuk permukaan yang lebih nyaman, kamu bisa memakai potongan aluminium foil 2×2 cm atau pita tembaga berperekat; pita tembaga juga bisa disolder, jadi lebih cocok untuk proyek permanen. Pad bisa kamu tempel di karton, bagian dalam kotak plastik, atau bagian belakang potongan kayu. Sentuhan juga terdeteksi melalui plastik, akrilik, atau kaca setebal 1–3 mm; hanya saja penurunan nilainya jadi lebih kecil, jadi kamu perlu mengukur ambang lagi. Jaga kabel dari pad ke ESP32 tetap pendek: kabel yang lebih panjang dari 20–30 cm berubah jadi antena, dan menyentuh kabelnya saja juga sudah memicu.

Membaca nilai touchRead dan menentukan ambang

Langkah pertama adalah melihat angka sebenarnya di rangkaianmu sendiri. Sketch di bawah membaca GPIO 4 (T0) dan GPIO 27 (T7) masing-masing delapan kali lalu mencetak rata-ratanya. Kalau kamu membuka Serial Plotter dari menu Tools di Arduino IDE, kamu bisa melihat kedua garis secara langsung dan memperhatikan bagaimana nilainya turun ketika disentuh.

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}

Sambil memperhatikan nilainya, catat tiga kondisi: pad tidak disentuh, jari menempel di pad, dan jari 1–2 cm di atas pad. Misalnya, kalau kamu membaca 62 ketika diam, 14 ketika disentuh, dan 45 ketika jari mendekat, ambang yang aman sekitar 60 persen dari nilai diam, jadi sekitar 37. Kalau ambang terlalu dekat dengan nilai diam, sentuhan terpicu begitu jari mendekat; kalau terlalu rendah, sentuhan ringan akan terlewat.

Tombol sentuh dengan kalibrasi otomatis

Daripada menulis angka ambang yang tetap, jauh lebih andal kalau nilai diam pad diukur ketika board mulai, lalu ambang dihitung dari nilai itu. Sketch di bawah mengambil rata-rata 50 pembacaan ketika mulai, menganggap penurunan 40 persen sebagai sentuhan, dan membalik kondisi LED. Pad dianggap dilepas ketika nilainya naik lagi di atas 80 persen dari nilai diam. Memakai dua ambang terpisah seperti ini disebut histeresis; cara ini mencegah pemicuan berulang ketika nilainya bergetar tepat di batas. Kalau kamu penasaran dengan sisi mekanis tombol, lihat artikel cara menghubungkan push button.

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}

Interrupt sentuhan dengan touchAttachInterrupt

Daripada terus-menerus memanggil touchRead, kamu bisa membiarkan hardware sentuh mengukur di latar belakang dan memanggil sebuah fungsi ketika nilainya turun di bawah ambang. Itulah tugas touchAttachInterrupt(pin, function, threshold). Di ESP32 klasik, interrupt terpicu ketika nilai yang diukur turun di bawah ambang, dan terus terpicu di setiap siklus pengukuran selama jari masih di pad. Jadi fungsi interrupt sebaiknya hanya mengatur flag (penanda), dan pekerjaan sebenarnya dilakukan di loop() dengan pengecekan waktu. Aturan umum interrupt sudah kami bahas di artikel interrupt Arduino.

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}

Di contoh ini ambangnya 40; nilai ini cocok untuk pad yang membaca sekitar 60 ketika diam, kalau tidak, ubah sesuai angka dari sketch pembacaan sebelumnya. Atribut IRAM_ATTR pada fungsi interrupt menaruh fungsi itu di memori cepat; ini disarankan untuk fungsi interrupt di ESP32. Untuk mematikan interrupt, panggil touchDetachInterrupt(pin). Di ESP32 klasik kamu juga bisa memanggil touchInterruptSetThresholdDirection(false) supaya interrupt terpicu ketika nilai naik di atas ambang; ini berguna untuk menangkap momen jari diangkat.

Slider sentuh tiga pad

Tiga pad yang berjajar sudah cukup untuk mengetahui posisi jarimu. Ketika jari berada di antara dua pad, nilai keduanya turun; dengan melihat seberapa besar penurunan di tiap pad, kamu menghitung posisinya dengan rata-rata berbobot. Kalau pad dipotong berbentuk zigzag atau chevron yang saling mengunci, bukan kotak biasa, jarimu akan menyentuh minimal dua pad di setiap posisi dan slider terasa jauh lebih halus. Tiga potong pita tembaga selebar 1,5 cm dengan celah 1–2 mm di antaranya adalah awal yang bagus.

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}

Ketika mulai, sketch menyimpan nilai diam setiap pad, lalu menghitung penurunannya di setiap perulangan. Kalau total penurunannya cukup besar, berarti ada jari di slider dan posisinya ditemukan di antara 0 dan 1000. Nilai itu kita ubah ke 0–255 dengan map() lalu dikirim ke LED dengan analogWrite(). analogWrite() berfungsi di versi 2.x maupun 3.x core Arduino ESP32. Cara kerja PWM bisa kamu baca di artikel Apa Itu PWM?.

Bangun dari deep sleep dengan sentuhan

Di proyek bertenaga baterai, kamu bisa membuat ESP32 masuk deep sleep dan baru membangunkannya ketika ada yang menyentuh pad. Dalam mode ini inti prosesor mati, tapi rangkaian pengukur sentuh tetap berjalan dengan daya rendah. Fungsi touchSleepWakeUpEnable(pin, threshold) mengatur ambang sekaligus mengaktifkan bangun lewat sentuhan. Di ESP32 klasik kamu bisa memakai beberapa pad sebagai sumber bangun (wake-up); di ESP32-S2 dan S3 hanya satu pad yang diizinkan. Setelah bangun, esp_sleep_get_touchpad_wakeup_status() memberi tahu pad mana yang membangunkan board. Detail deep sleep dan angka arusnya sudah kami bahas di artikel deep sleep ESP32.

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}

Setelah bangun, kode mulai lagi dari setup(), karena RAM dikosongkan selama deep sleep. Untuk menyimpan jumlah bangun, kita menaruh RTC_DATA_ATTR di depan variabel; variabel seperti ini disimpan di memori RTC kecil yang tetap terjaga selama tidur. Karena pengukuran sentuh tetap berjalan selama tidur, arus deep sleep sedikit lebih tinggi dibanding bangun dengan timer; ingat ini ketika memperkirakan umur baterai. Blok #if di kode membuat program yang sama bisa dikompilasi dengan ambang yang benar di ESP32-S2 dan S3 juga.

Pin sentuh ESP32 dengan MicroPython

Kalau ESP32-mu sudah diisi MicroPython, hal yang sama dilakukan dengan class TouchPad di modul machine. Metode read() mengembalikan nilai yang sama dengan touchRead() di Arduino; di ESP32 klasik nilainya tetap turun ketika disentuh. Untuk bangun dari tidur, pakai esp32.wake_on_touch(True) dan metode config(threshold) milik pad.

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 tidak punya sensor sentuh kapasitif bawaan. Kalau kamu ingin tombol sentuh dengan Pico atau Arduino Uno, solusi termudah adalah modul TTP223 siap pakai; modul ini mendeteksi sentuhan sendiri dan memberimu sinyal digital biasa.

Masalah kelembapan, air, dan derau

Sensor kapasitif mendeteksi air sama seperti jari. Setetes air atau kelembapan tinggi di pad menambah kapasitansi, nilainya turun, dan tombol bisa terpicu sendiri. Di proyek kamar mandi, dapur, atau luar ruangan, taruh pad di balik permukaan yang tidak menahan air, pilih ambang yang sedikit lebih rendah, dan syaratkan sentuhan berlangsung minimal 50–100 ms. Kabel panjang, relay dan motor di dekatnya, serta catu daya USB yang jelek juga membuat nilainya naik-turun. Tabel di bawah merangkum masalah yang paling sering muncul beserta solusinya.

Pin sentuh di ESP32-S3 dan model lain

ESP32-S2 dan ESP32-S3 memakai hardware sentuh generasi kedua dan berbeda dari ESP32 klasik dalam tiga hal penting. Pertama, kanalnya ada di GPIO 1–14 dan jumlahnya 14; T1 adalah GPIO 1 dan T14 adalah GPIO 14. Kedua, nilainya jauh lebih besar dan naik ketika disentuh; pad yang membaca sekitar 20.000 ketika diam bisa naik di atas 40.000 ketika disentuh. Ketiga, ambang di touchAttachInterrupt dan touchSleepWakeUpEnable bukan nilai absolut, melainkan besar kenaikan dari nilai diam. Di S3 kamu juga bisa memakai touchInterruptGetLastStatus(pin) untuk mengetahui apakah pad masih ditekan. ESP32-C3 dan ESP32-C6 sama sekali tidak punya sensor sentuh. Kalau kamu menulis kode untuk lebih dari satu model, pisahkan dengan CONFIG_IDF_TARGET_ESP32 seperti di contoh bangun dari tidur.

Ide proyek dengan pin sentuh

• Lampu meja: sakelar nyala/mati tak terlihat dari pita tembaga yang ditempel di balik penutup kayu, dengan sentuhan lama untuk mengatur kecerahan.
• Dimmer slider: ubah kecerahan dan warna LED strip LED WS2812B dengan slider tiga pad.
• Bel pintu atau perangkat catatan bertenaga baterai: ESP32 menunggu dalam deep sleep, bangun ketika pad disentuh, lalu mengirim notifikasi lewat Wi-Fi.
• Piano buah: mainan dengan kabel ke pisang dan apel yang memainkan nada berbeda untuk tiap buah; suaranya bisa dari buzzer.
• Panel kode tersembunyi: kunci yang terbuka ketika empat pad yang tersembunyi di dalam kotak disentuh dengan urutan yang benar.

Pin sentuh ESP32 memberi proyekmu antarmuka sentuh hanya dengan beberapa sentimeter foil dan beberapa baris kode. Di aplikasi BlueGrays kamu akan menemukan proyek seperti LED Berkedip dengan ESP32, kendali LED dengan tombol, kecerahan LED dengan PWM, dan deep sleep, masing-masing lengkap dengan skema rangkaian dan kode langkah demi langkah; ganti tombolnya dengan pad sentuh dari panduan ini untuk membuat versimu sendiri.