Capteur tactile TTP223 avec Arduino : modes, câblage et lampe

Le capteur tactile TTP223 est un module tactile capacitif à une touche, très bon marché, qui remplace un bouton-poussoir mécanique et détecte ton doigt grâce à une variation de capacité. Il ne possède que trois broches (VCC, GND et I/O) : quand tu le touches, la sortie passe à HIGH, et quand tu retires ton doigt, elle redescend à LOW. Grâce à cette simplicité, tu le lis sur un Arduino avec digitalRead() exactement comme un bouton, et comme il fonctionne entre 2 et 5,5 V, il se branche aussi directement sur un ESP32 ou une Raspberry Pi Pico. Sans pièce mobile, il ne s'use pas, ne clique pas et peut se cacher derrière une fine couche de plastique, de verre ou de bois.

Dans ce guide, tu vas apprendre pas à pas ce qui se passe à l'intérieur du TTP223, comment utiliser les ponts de soudure A et B de la carte pour choisir le mode momentané ou bascule (toggle) et une sortie active à l'état haut ou bas, comment fabriquer avec Arduino une lampe tactile qui s'allume d'une touche brève et se règle d'une touche longue, comment faire fonctionner le capteur derrière un panneau, comment utiliser plusieurs touches, en quoi il diffère des broches tactiles intégrées de l'ESP32 et comment l'utiliser sur la Pico en MicroPython.

Qu'est-ce que le capteur tactile TTP223 et comment fonctionne-t-il ?

La pastille de cuivre du module et la surface de masse (GND) de la carte forment un minuscule condensateur de quelques picofarads. Quand ton doigt s'approche de la pastille, ton corps s'ajoute à ce condensateur et la capacité totale augmente de quelques picofarads. L'oscillateur de mesure du TTP223, d'environ 1 MHz, perçoit cette hausse comme un changement de fréquence, compare le résultat à une valeur de référence qu'il mémorise et bascule la sortie si l'écart est suffisant. La formule du condensateur plan C = ε·A/d s'applique ici aussi : plus la surface de la pastille (A) est grande et plus le matériau entre le doigt et la pastille (d) est fin, meilleure est la détection.

La puce fixe elle-même sa valeur de référence. Dès que tu la mets sous tension, elle mesure son environnement pendant environ 0,5 seconde et ignore les contacts pendant ce temps. Ensuite, tant que personne ne la touche, elle se recalibre environ toutes les 4 secondes, ce qui compense peu à peu les variations lentes comme la température et l'humidité. C'est pourquoi le capteur considère comme "non touché" tout ce qui entoure la pastille à la mise sous tension : si ton doigt est posé dessus au démarrage, il ne te verra pas du tout.

Dans la version TTP223-BA6 utilisée sur ces modules, certaines options sont figées dans le boîtier : la puce fonctionne toujours en mode basse consommation, et la limite de 100 secondes de "durée maximale d'activation" présente sur d'autres boîtiers est désactivée. En mode basse consommation, la puce ne consomme que quelques microampères, mais elle peut mettre jusqu'à environ 220 ms pour réagir au premier contact. Une fois un contact détecté, elle reste environ 12 secondes en mode rapide et répond beaucoup plus vite aux contacts suivants. Tu ne remarqueras pas ce délai sur une lampe ou une sonnette, mais garde-le en tête si tu fabriques une manette de jeu qui exige des réactions rapides.

Brochage et câblage du TTP223

Comme la broche de sortie pilote elle-même le signal à HIGH et à LOW, tu n'as besoin ni d'INPUT_PULLUP ni d'une résistance externe sur l'Arduino : il suffit de déclarer la broche en INPUT. Il n'y a pas de rebonds comme avec les boutons mécaniques, car la puce ne change sa sortie qu'une fois le contact stable. Si tu veux néanmoins que ton code compte un contact comme un seul événement, utilise la détection de front expliquée dans brancher un bouton sur Arduino.

Choisir le mode avec les ponts de soudure A et B

À côté de la puce, le module porte deux petites paires de pastilles de soudure marquées A et B. Elles sont reliées à deux broches d'option de la puce : sur la plupart des modules, A choisit si la sortie est active à l'état haut ou bas (AHLB), et B si le capteur fonctionne en mode momentané ou bascule (TOG). À l'intérieur de la puce, ces broches sont tirées vers GND par une résistance, donc l'option vaut "0" quand les pastilles sont ouvertes ; relie les deux pastilles avec une goutte de soudure et elle passe à "1". Après avoir modifié un pont, le plus sûr est de couper puis de rétablir l'alimentation. Si les marquages de ta carte sont différents, tu peux facilement vérifier le mode avec la LED du premier programme de test.

Premier test avec Arduino : lire un contact

1. Relie la broche VCC du module à la broche 5V de l'Arduino, GND à GND et la broche I/O à D2.
2. Téléverse le programme ci-dessous et ouvre le moniteur série à 9600 bauds.
3. Après le démarrage de la carte, attends environ une seconde sans toucher la pastille ; la puce se calibre pendant ce temps.
4. Touche la pastille du doigt : la LED intégrée de l'Arduino sur la broche 13 (et, sur la plupart des modules, la LED de la carte elle-même) doit s'allumer et le nombre de contacts dans le moniteur série doit augmenter de un.
5. Tant que ton doigt reste sur la pastille, la LED reste allumée ; le compteur, lui, n'augmente qu'une fois par nouveau contact.

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}

La partie la plus importante du code est la détection de front. La lecture précédente est stockée dans la variable lastState ; si la nouvelle lecture vaut HIGH et la précédente LOW, c'est un nouveau contact. Sans ce test, le compteur augmenterait à chaque tour de boucle tant que ton doigt reste sur la pastille, c'est-à-dire des milliers de fois par seconde. L'attente de 600 ms dans setup() garantit que la puce a fini son calibrage quand l'Arduino et le module sont alimentés en même temps. Nous avons choisi D2 parce que c'est une broche d'interruption de l'Uno ; si tu veux, tu peux aussi capter le contact par interruption avec attachInterrupt(digitalPinToInterrupt(2), fonction, RISING).

Projet : une lampe tactile avec Arduino

Fabriquons maintenant une vraie lampe tactile : une touche brève l'allume et l'éteint, si tu laisses le doigt sur la pastille quand elle est allumée la lumière baisse doucement, et la touche longue suivante la fait remonter. Comme la luminosité est réglée en PWM, on branche la lampe sur D9, l'une des broches PWM de l'Uno. Pour les essais, une LED et une résistance de 220 Ω sur D9 suffisent (trouve la bonne valeur avec le calculateur de résistance pour LED). Pour un ruban LED 12 V, intercale un MOSFET à niveau logique comme l'IRLZ44N ; tous les détails sont dans utiliser un MOSFET avec Arduino.

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}

Remarque qu'il n'y a aucun delay() dans le code : toute la temporisation repose sur millis(), donc la boucle tourne en permanence et ne rate aucun contact. Pour en savoir plus sur cette technique, lis millis() ou delay(). Comme la dernière luminosité reste dans la variable brightness, la lampe se rallume au niveau que tu avais réglé en dernier, exactement comme les lampes de chevet tactiles du commerce.

Détecter à travers un matériau fin

L'atout préféré du TTP223, c'est qu'il fonctionne depuis l'intérieur d'un boîtier sans trou. Le plastique, l'acrylique, le verre, le bois, le papier et le tissu laissent passer le champ électrique ; le matériau entre la pastille et le doigt joue le rôle de diélectrique d'un condensateur. Plus le matériau est épais, plus d augmente dans la formule et plus la capacité entre le doigt et la pastille diminue ; doubler l'épaisseur divise à peu près cette capacité par deux. Le verre a une constante diélectrique plus élevée que la plupart des plastiques, donc un verre de même épaisseur donne en général de meilleurs résultats. En pratique, le module fonctionne le plus souvent sans souci derrière un panneau de plastique, d'acrylique ou de verre de 1 à 3 mm ; avec des panneaux plus épais, il te faudra une pastille plus grande, et teste toujours avec ton propre matériau.

• Pas de lame d'air : l'air a une constante diélectrique de 1, et même un espace de 1 mm réduit nettement la sensibilité. Colle fermement le module contre le panneau, pastille tournée vers lui, avec un adhésif double face fin ou de la colle.
• Agrandis la pastille : pour une zone tactile plus grande, découpe une électrode dans du ruban de cuivre ou du papier aluminium, gratte doucement le vernis protecteur sur un coin de la pastille et soude l'électrode avec un fil très court. Plus le fil est long, plus il ajoute sa propre capacité et plus le capteur devient instable.
• Évite le métal : les panneaux métalliques, les matériaux chargés en métal et les peintures métallisées concentrent le champ électrique sur eux ; le capteur ne détecte alors rien ou se déclenche tout seul.
• Réduis une sensibilité excessive : si le capteur se déclenche avant que ton doigt n'approche, ajoute un petit condensateur céramique de 5 à 20 pF (Cs) entre la pastille et GND ; plus la valeur est grande, plus la sensibilité baisse, avec 50 pF comme limite. Tu peux décoder le marquage du condensateur (par ex. 100 = 10 pF, 220 = 22 pF) avec l'outil code des condensateurs.
• Monte d'abord, alimente ensuite : comme la puce prend son environnement comme référence à la mise sous tension, n'alimente le montage qu'une fois le panneau et le couvercle en place. Si tu poses le panneau sous tension, la puce peut le prendre pour un contact permanent ; il suffit alors de couper et de rétablir l'alimentation.

Utiliser plusieurs touches tactiles

Chaque TTP223 surveille sa propre pastille de façon indépendante ; pour quatre touches, tu branches quatre modules sur quatre broches numériques différentes, les modules partageant VCC et GND. Si les touches sont très rapprochées, ton doigt peut aussi influencer la pastille voisine ; laisse au moins 1 à 2 cm entre les pastilles et éloigne les modules des fils de moteurs ou de relais. Le programme ci-dessous utilise quatre TTP223 et un buzzer passif pour créer un petit piano tactile : chaque touche joue sa note, et le son s'arrête quand tu lèves le doigt.

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}

Comme tone() ne peut jouer qu'une note à la fois, le code choisit la première touche touchée et ne met la note à jour que lorsqu'elle change, pour éviter les grésillements. Sur l'Uno, tone() utilise le Timer2, donc analogWrite ne fonctionne pas sur les broches 3 et 11 pendant que le buzzer joue ; ce n'est pas un problème ici, car le piano n'utilise D3 qu'en entrée. Quand le nombre de touches augmente, il est plus propre de passer à des puces multicanaux plutôt qu'à un module par touche : le TTP224 offre quatre touches avec quatre sorties séparées, le TTP229 lit 8 ou 16 touches via une interface série à deux fils, et le MPR121 surveille 12 électrodes en I2C.

ESP32 : TTP223 ou broches tactiles intégrées ?

L'ESP32 classique intègre un capteur tactile capacitif, et 10 broches (T0–T9) peuvent servir de touches tactiles sans aucun module : GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 et 32, dans cet ordre. La fonction touchRead() renvoie une valeur brute ; sur l'ESP32 classique, cette valeur baisse quand tu touches la broche, alors que sur l'ESP32-S2 et le S3 elle augmente. L'ESP32-C3 n'a aucun capteur tactile. Pour tout savoir sur les broches intégrées, consulte les broches tactiles de l'ESP32 ; le tableau ci-dessous compare les deux approches.

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}

Au démarrage, ce programme mesure la valeur de T0 sans contact et en prend 70 % comme seuil ; observe la valeur brute dans le moniteur série (115200 bauds) pour ajuster ce rapport à ton câblage. Si tu utilises un ESP32-S3, la valeur augmente au toucher, inverse donc la comparaison (par exemple seuil = valeur mesurée × 1,3 et raw > seuil). Nous avons aussi branché le TTP223 sur GPIO 26 parce que c'est un GPIO RTC : avec esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1), tu peux mettre l'ESP32 en deep sleep et le réveiller d'un simple contact. Comme le TTP223 ne consomme que quelques microampères, ils forment un duo idéal pour les projets sur batterie ; plus de détails dans le deep sleep de l'ESP32.

TTP223 avec la Raspberry Pi Pico (MicroPython)

La puce RP2040 de la Pico n'a pas de capteur tactile, le TTP223 est donc le moyen le plus simple d'ajouter une touche tactile à une Pico. Alimente le module par la broche 3V3(OUT) (broche physique 36) et relie la broche I/O à GP15 (broche physique 20). Le code MicroPython ci-dessous inverse l'état de la LED intégrée à chaque contact. Comme il capte le contact par interruption (IRQ), aucun contact n'est perdu même si la boucle principale est occupée à autre chose. Si tu ne sais pas encore installer MicroPython sur la Pico, commence par Qu'est-ce que la 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)

Dans les versions récentes de MicroPython, le nom Pin("LED") désigne la LED intégrée aussi bien sur la Pico que sur la Pico W. Si tu as soudé le pont B pour passer le module en mode bascule, tu n'as même pas besoin de l'interruption : il suffit d'écrire led.value(touch.value()) dans la boucle, puisque c'est désormais la puce elle-même qui mémorise l'état marche/arrêt. Même si la sortie de la puce ne rebondit pas, le verrou de 250 ms du code empêche de courtes impulsions parasites sur des fils longs de faire basculer la LED deux fois.

Idées de projets avec le TTP223

• Veilleuse tactile : ajoute une LDR pour que la lampe ne réagisse au contact que dans l'obscurité.
• Lampe à couleurs changeantes : change la couleur d'un anneau WS2812B NeoPixel à chaque contact et règle la luminosité par un contact long.
• Serrure à code cachée : place quatre TTP223 derrière un panneau en acrylique ; en touchant les touches dans le bon ordre, un servomoteur ouvre le verrou.
• Sonnette sans trou : colle le capteur à l'intérieur d'un boîtier en plastique ; au contact, un DFPlayer Mini joue la mélodie de la sonnette.
• Interrupteur tactile de prise : allume et éteins une lampe de bureau ou un ventilateur avec un module relais.
• Télécommande sur pile : garde un ESP32 en deep sleep ; quand tu touches le TTP223, il se réveille et envoie un ordre via ESP-NOW.

Erreurs fréquentes et solutions

Le TTP223 est la façon la plus simple d'ajouter une interface tactile moderne à tes projets avec un module très bon marché : il remplace le bouton mécanique, fonctionne derrière des panneaux sans trou et s'entend avec tous les microcontrôleurs. Essaie d'abord de le lire avec le réglage d'usine, puis consolide la détection de front et la logique de l'appui long avec les exemples de la lampe et du piano. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et code, des projets pour allumer une LED avec un bouton, une LED marche/arrêt, des projets de boutons avec l'ESP32 et la Pico ainsi que la commande d'une ampoule secteur, et tu pourras tous les rendre tactiles en remplaçant le bouton par un TTP223.