=========================
Capteur capacitif tactile
=========================

Un capteur tactile peut-être facilement fabriqué à partie d'une plaque conductrice (ex. plaque de circuit imprimé, papier en aluminium, ...) de surface suffisante. Un film en plastique collé sur la plaque fait office d'isolant.

.. figure:: images/capteur_tactile/capteur_capacitif_tactile_equiv.png
   :width: 1022
   :height: 359
   :scale: 60 %
   :alt:
   :align: center

   Equivalence d'un Capteur tactile capacitif

Par rapport à la terre, ce capteur tactile est équivalent à un condensateur de faible capacité (quelques centaines de pF). Cette capacité croît lorsque la main s'approche de la surface du capteur.



Montage
=======


.. figure:: images/capteur_tactile/capteur_capacitif_tactile_arduino.png
   :width: 1022
   :height: 484
   :scale: 60 %
   :alt:
   :align: center

   Montage Arduino Uno R3 avec capteur tactile capacitif

Un condensateur de capacité :math:`C_0` est placé en parallèle avec le capteur dans le but de fixer une constante de temps minimale. Cet ensemble a pour capacité équivalente :

.. math:: 

   C_{eq} = C_0 + C_{capt}

Ainsi, en approchant la main de la surface du capteur, la capacité équivalente :math:`C_{eq}` augmente.


La broche D3 de l'Arduino est utilisée pour charger (et décharge) le condensateur équivalent à travers une résistance de :math:`100~\rm M\Omega` sous une tension constante de :math:`5~\rm V`.


La broche D2 détecte la moitié de la charge du condensateur. En effet, une entrée digitale bascule d'un niveau logique :code:`0` à un niveau logique :code:`1` avec une tension de seuil environ égale à :math:`\dfrac{V_{CC}}{2} = \dfrac{5,0}{2} = 2,5~\rm V`.




Durées de basculement de la broche D2
=====================================

Plus la valeur de la capacité est élevée, plus le basculement de l'entrée D2 est retardé !

On mesure les instants :math:`t_0` et :math:`t_1` pour lesquels l'entrée D2 change d'état **sans contact** puis **avec contact**.


.. figure:: images/capteur_tactile/charge_courbes_1.png
   :width: 1000
   :height: 400
   :scale: 60 %
   :alt:
   :align: center

   Basculement de l'entrée digitale D2 **sans contact**

.. figure:: images/capteur_tactile/charge_courbes_2.png
   :width: 1000
   :height: 400
   :scale: 60 %
   :alt:
   :align: center

   Basculement de l'entrée digitale D2 **avec contact**


Le programme ci-dessous utilise une **interruption** qui détecte le basculement sur un front montant de l'entrée D2. Au déclenchement de cette interruption, la fonction :code:`detection()` est exécutée. Cette fonction mesure et affiche l'instant où l'entrée D2 bascule.

.. code:: Arduino

   /* Capteur capacitif tactile
    * Mesure de la durée du basculement de l'entrée digitale D2 (seuil de 2,5V)
    * David THERINCOURT - 2025 
    */

   int pinD3 = 3;  // Broche D3 
   int pinD2 = 2;  // Broche D2 

   unsigned long t_init;            // Instant initial
   unsigned long t_rise;            // Instant de basculement

   void setup() {
      Serial.begin(9600);            // Initialisation du port série
      pinMode(pinD3, OUTPUT);        // broche D3 en sortie (charge condensateur)
      pinMode(pinD2, INPUT);         // broche D2 en entrée (lecture tension condensateur)
      attachInterrupt(digitalPinToInterrupt(pinD2),  detection, RISING); // Parmetrage interruption
   }

   void loop() {
      // DEBUT CHARGE COMPLETE
      digitalWrite(pinD3, 1);        // D3 à 5V
      t_init = micros();             // Mesure instant début
      delay(500);                    // Temporisation pour charge complète

      // DEBUT DECHAGRE COMPLETE
      digitalWrite(pinD3, 0);        // Début décharge du condensateur
      delay(500);                    // Temporisation pour charge complète
   }

   void detection() {
      t_rise = micros();             // Mesure instant du basculement de 0 à 5V
      Serial.print(t_rise - t_init); // Affichage durée de basculement
      Serial.println(" µs");         // Affichage unité + saut de ligne
   }


.. figure:: images/capteur_tactile/duree_basculement_moniteur_serie.png
   :width: 1004
   :height: 407
   :scale: 70 %
   :alt:
   :align: center

   Moments de basculement de l'entrée D2 



On mesure donc :

.. math:: 

   t_0 \approx 640~\rm µs
   \qquad
   t_1 \approx 1350~\rm µs


.. warning:: 

   La fonction :code:`micros()` renvoie une durée avec une résolution de :math:`4~\rm µs`.


Programme final
===============

.. figure:: images/capteur_tactile/capteur_capacitif_tactile_arduino_LED.png
   :width: 1022
   :height: 484
   :scale: 60 %
   :alt:
   :align: center

   Montage complet avec une LED


En choisissant de lire l'état logique de la broche D2 à l'instant :math:`t_m` tel que :

.. math:: 

   t_{m} = \dfrac{t_0+t_1}{2} = \dfrac{640+1350}{2} \approx 1000 \rm \mu s

On obtient :

- :code:`1` sans contact (LED allumée)

- :code:`0` avec contact (LED éteinte)


.. code:: arduino

   /* Capteur capacitif tactile
    * R = 1M    C = 1nF  + plaque epoxy cuivrée 30cm x 10cm
    * David THERINCOURT - 2025 
    */

   int pinD3  = 3; // Broche D3 pour la charge
   int pinD2  = 2; // Broche D2 pour la lecture de la tension du condensateur
   int pinLed = 8; // Broche LED
   int etat;       // Etat de D3 

   void setup() {
      Serial.begin(9600);          // Initialisation du port série
      pinMode(pinD3, OUTPUT);      // D2 en sortie (charge condensateur)
      pinMode(pinD2, INPUT);       // D3 en entrée (lecture tension condensateur)
      pinMode(pinLed, OUTPUT);     // LED sur broche 8
   }

   void loop() {
      // CHARGE DU CONDENSATEUR
      digitalWrite(pinD3, HIGH);   // D3 à 5V 
      delayMicroseconds(1000);     // Temporisation en µs 
      etat = digitalRead(pinD2);   // Lecture de l'état logique de D2
      Serial.println(etat);        // Affichage de l'état logique de D2
      digitalWrite(pinLed, etat);  // Allumer/éteindre la LED

      // DECHARGE TOTALE
      digitalWrite(pinD3, 0);      // D3 à 0V
      delay(1000);                 // Temporisation de 1s
   }