Kit Cypress PSoC 4 : programmation des touches sensitives à détection capacitive CapSense

Les Socs du fabricant de semi-conducteurs américain Cypress (acquis récemment par le groupe Infineon), appelés PSoC pour Programmable System on Chip, sont des circuits intégrés rassemblant sur une seule puce à microcontrôleur : un CPU (ARM Cortex 32 ou 64 bits), de la mémoire statique et dynamique, des entrées-sorties, parfois avec divers modules pour la communication sans fil (Wi-Fi, Bluetooth…), des capteurs et toute une gamme de périphériques et d’unités fonctionnelles analogiques et numériques.

La particularité des PSoC en plus d’être programmables, est qu’ils présentent des unités configurables, ce qui permet aux ingénieurs et makers de concevoir des sous-systèmes câblés mixtes, numériques ou analogiques, déchargeant le CPU de tâches coûteuses ou répétitives.

Pour vous donner un aperçu sur l’architecture des PSoC, imaginez le code suivant implanté dans un microcontrôleur classique :

 

Sélectionnez

if (Input1_Read() && !Input2_Read()){
    LED_Pin_Write(1); // Allumer LED
}
else {
    LED_Pin_Write(0); // Eteindre LED
}

Au lieu de ce code, vous pouvez réaliser le schéma simple ci-dessous en câblant des portes logiques dans PSoC Creator :

À la génération du projet, les unités logiques du processeur PSoC sont reconfigurées afin d’activer les portes logiques, et les entrées-sorties sont routées suivant les indications du schéma. Avec ce séquenceur câblé, aucun cycle n’est consommé par le CPU.

Pour découvrir les kits de développement PSoC de Cypress et leur EDI PSoC Creator, vous pouvez consulter les tutoriels suivants :

• Débuter avec les cartes Cypress PSoC et l'EDI PSoC Creator ;
• Cypress PSoC 4 Pioneer Kit : piloter un moteur à courant continu avec un joystick.

Ainsi, même si la communauté Arduino continue de grandir, je reste fidèle à ma carte PSoC 4 et son EDI (Environnement de Design Intégré) PSoC Creator.

La carte CY8CKIT-042 du PSoC 4 Pioneer Kit que je ressors donc à nouveau pour l’occasion comporte une glissière axiale (slider) sensitive en surface de la carte sur le côté.

Les applications de cette glissière sont nombreuses. On peut par exemple reproduire le fonctionnement d’une roulette mécanique pour faire monter ou descendre quelque chose (un store déroulant, un niveau sonore ou de luminosité, etc.)

Dans cet article, on propose de découvrir comment exploiter le contrôleur CapSense pour les boutons sensitifs à détection capacitive dans l’EDI PSoC Creator.

Les boutons mécaniques restent encore largement utilisés, mais ils présentent pourtant des inconvénients :

• ils deviennent moins fiables et s'usent avec le temps à cause des parties mécaniques en mouvement ;
• l'humidité et la poussière s'infiltrent à cause des jeux de fonctionnement entre les parties fixes et mobiles du bouton ;
• conséquence de l'usure et de l'encrassement des contacts avec le temps, il faut appuyer de plus en plus fort sur le bouton ;
• un bouton mécanique est un assemblage de pièces coûteuses à fabriquer avant de les assembler ;
• pour loger les boutons, il faut souvent découper des ouvertures dans des panneaux ou dans les coques de boîtier ;
• pour couronner le tout, ils ne sont pas toujours très esthétiques.

À côté de cela, une infime pression, voire un simple effleurement du doigt sur un bouton sensitif suffit pour déclencher une action. Vous retrouvez maintenant ces dispositifs sensitifs sur de nombreux appareils modernes : smartphones, tablettes, imprimantes, chaînes Hi-Fi, écrans plats, produits électroménagers, etc.

La technologie développée par Cypress (nommée CapSense®) permet la détection de la perturbation de capacité électrique à l'approche du doigt :

L’électronique du contrôleur et le firmware fournis par le constructeur permettent une détection fiable avec une grande immunité aux bruits. Le système est capable de filtrer les « fausses touches » dues par exemple à la projection de liquide sur la surface sensitive.

Ainsi, lorsque vous approchez votre doigt du revêtement conducteur (overlay), la capacité parasite initiale C_P en l’absence de toucher entre les électrodes augmente pour devenir : C_S=C_P+C_F

Un circuit spécialisé permet d'adapter le signal analogique perturbé par un changement de capacité en une valeur numérique issue d'un comptage d'impulsions (valeur nommée raw count) :

Par exemple, quand le doigt s'approche du capteur, la capacité C_S augmente ce qui génère une augmentation du courant électrique dans le circuit. Un signal modulé dont la fréquence augmente est alors produit, et on compte le nombre d’impulsions dans une fenêtre de temps pour en sortir une valeur numérique :

L’augmentation de la valeur produite en sortie à l’approche du doigt est donc proportionnelle à l'augmentation de la capacité en pF (picofarad). Le firmware traite alors l’information et est capable d’interpréter s’il y a détection d'une touche ou non.

Cypress propose de nombreux kits équipés de touches sensitives CapSense, notamment sur ses cartes de développement à microcontrôleur PSoC 4. Si mon kit référencé CY8CKIT-042 comprend une glissière axiale, le kit CY8CKIT-044, par exemple, permet la détection de mouvements plus complexes (control gesture) avec la forme et la disposition particulière de ses cinq boutons sensitifs :

Avec ce même kit, deux ports disponibles sur le côté de la carte permettent la mise en œuvre d’une détection de proximité capacitive :

Le plus récent CY8CKIT-062-BLE (32-bit ARM Cortex-M4 PSoC 6) est équipé d’une glissière axiale et de deux boutons sensitifs CapSense :

Plus original, le kit CY8CKIT-041-41XX PSoC 4100S quant à lui comprend une carte embarquée PSoC 4100S à clipser dans un boîtier :

Le boîtier est fermé avec une surface sensitive raccordée à la carte par une nappe. Celle-ci comporte des boutons ainsi qu’un trackpad CapSense (composé de 7x7 zones sensitives), et permet la détection de proximité :

Il reste à recouvrir la surface d’un film personnalisé, ici pour une application de sélection de couleur pour allumer une LED, et de téléverser son application via la prise USB depuis PSoC Creator :

L’API propose alors des fonctionnalités avancées de type Trackpads with gestures pour la reconnaissance de mouvements tels que : scroll, flick, swipe, zoom, rotate… avec un ou deux doigts.

La qualité de la détection des touches dépend de nombreux facteurs : fabrication du circuit imprimé, matériau et épaisseur de la couche de revêtement de la zone sensitive, dimensions et formes du bouton, environnement extérieur, etc. Certains réglages internes au fonctionnement du modulateur CSD ou des paramètres du firmware relatifs au traitement des valeurs brutes produites en sortie (Raw Count) vont aussi influencer la sensibilité.

Tout le processus de réglage (tuning) consiste justement à déterminer les valeurs optimales des paramètres et de maintenir la meilleure sensibilité possible au toucher quelles que soient les perturbations qui peuvent se produire dans l'environnement du bouton sensitif.

Comme le processus d'optimisation est un processus itératif coûteux en temps dans le cycle de développement, Cypress a mis au point le procédé SmartSense®, un ensemble d'algorithmes d'autoétalonnage (auto-tuning) afin de compenser automatiquement les variations d'environnement et garder des performances optimales.

Afin de comprendre les principaux réglages du capteur CapSense, voyons quelques définitions.

Raw Count : comme cela a été dit précédemment, les algorithmes et matériels CapSense traduisent la variation de capacité au moment du toucher en une valeur numérique produite en sortie (comptage d'impulsions). Cette valeur numérique brute permettra d'indiquer l'état du capteur après traitement.

Baseline – (niveau de référence) : une référence doit être établie en l’absence de toucher à partir des données filtrées. En faisant la différence entre les données brutes et le niveau de référence (raw count - baseline), on obtient un nouveau signal qui permettra aux algorithmes de prendre une décision concernant la détection de touches.

Seulement, cette référence peut dériver en fonction des changements d’environnement autour du bouton sensitif (température, humidité, perturbations électromagnétiques, etc.) et un soin doit donc être apporté à la mise à jour de la baseline.

Pour cela, le paramètre Noise Threshold (seuil de bruit) permet de différencier le signal, du bruit. Si la variation du signal par rapport à la référence est en dessous de ce seuil, le système considère que la faible variation n’est pas due à l’approche d’un corps, mais à du bruit ou une dérive du signal et la baseline est mise à jour ; le signal (raw count – baseline) reste alors 0. Dans le cas contraire, il s’agit d’un corps qui s’approche et la baseline est maintenue au niveau relevé juste avant la détection de l’approche du corps, jusqu’à ce que le signal redescende quand le corps s’éloigne du bouton.

Finger Threshold – (seuil de détection de touche) : un paramètre associé au paramètre Hysteresis pour déterminer l’état de détection ON/OFF du capteur avec l’équation :

État du capteur =

• Touch ON, si Signal ≥ Finger Threshold + Hysteresis
• Touch OFF, si Signal ≤ Finger Threshold − Hysteresis

Pour maintenir les performances optimales et s’adapter aux dérives et sources de bruit extérieures, le procédé SmartSense prend en charge de gérer automatiquement la grande majorité des 17 paramètres requis pour le fonctionnement d’un capteur sensitif CapSense. Le bruit peut être mesuré en permanence et les différents paramètres ou seuils sont ajustés dynamiquement afin de maintenir le rapport signal-bruit (Signal-to-Noise Ratio) le plus élevé possible et éviter ainsi la détection de fausses touches.

Dans les quelques cas particuliers où l’auto-tuning SmarSense ne donne pas des résultats satisfaisants, il vous reste la possibilité d’ajuster les paramètres manuellement (Manual-tuning). Il faudra alors vous reporter aux procédures pas-à-pas de réglages manuels fournies par Cypress (voir la documentation en annexeAnnexe - Documentation Cypress, en particulier le CapSense Design Guide).

Un widget désigne un bouton ou un ensemble de boutons sensitifs qui peuvent être de formes différentes, et agencés de façon à former une interface tactile particulière avec l’utilisateur : un bouton simple, une matrice de boutons, un pavé tactile (touchpad), une glissière axiale ou radiale, etc.

La carte référencée CY8CKIT-042 dont je dispose comprend une rangée de cinq segments sensitifs en double chevron pour former une glissière axiale (ports P1[1] à P1[5]) :

La forme en double chevron de la touche n’est pas due au hasard. Le but est d’obtenir une réponse linéaire de la position estimée du doigt lorsque celui-ci balaye la glissière sur son axe.

Idéalement, lorsque le doigt parcourt la glissière d’une extrémité à l’autre, il y a recouvrement des signaux de deux segments adjacents comme indiqué dans la figure ci-dessous :

Il est difficile d’obtenir une réponse linéaire en pratique, et la forme en double chevron des touches est ce qui permet de s’en approcher le plus, mais il faut alors prendre en compte les signaux sur trois segments adjacents pour estimer précisément la position du centroïde (centre de l’aire de contact).

Sur l’image ci-dessus, le signal sera le plus fort sur le segment 2, mais l’algorithme CapSense va regarder la force des signaux sur les segments adjacents 1 et 3 pour calculer le centre de l’aire de contact (ou « centroïde ») avec la formule :

Dans l’exemple ci-dessous, le signal est maximal sur le segment 1 (donc X=1, et n=5 pour 5 segments), mais les segments adjacents 0 et 2 sont aussi impactés.

La position du centroïde peut évoluer ici entre la position 0 et 255 (resolution=255 par défaut). Avec mon doigt quelque part sur le segment 1, la position du centroïde est :

Pour mettre en œuvre un widget CapSense, il suffit de faire glisser le bloc correspondant depuis le catalogue des composants dans la fenêtre TopDesign de PSoC Creator.

On y dépose également un bloc de communication en mode EzI²C. Grâce à lui, le contrôleur CapSense pourra envoyer des données et les transmettre au PC via le câble USB en mode Tuning pour visualiser l’état du widget dans une interface graphique et tracer des courbes.

Dans la fenêtre TopDesign, on a finalement :

Dans le bloc CapSense, on commence par configurer le widget Linear Slider :

Puis on active le tuning en mode automatique SmartSense :

Enfin, on renseigne le nom du bloc de communication qui transmettra les données au PC :

Le bloc de communication (SCB pour Serial Communication Bloc) configuré en mode EzI²C recevra les paramètres suivants :

Le programme minimal pour visualiser l’état du widget sur le PC est le suivant :

#include "project.h"
int main(void)
{
  CyGlobalIntEnable; /* Enable global interrupts. */
  CapSense_TunerStart();

  while(1)
  {
    CapSense_TunerComm();
  }
}

Une fois le programme téléversé dans la carte, on lance le Tuner :

Il reste à configurer les paramètres de communication, et démarrer le tuning en cliquant sur « Start » :

En mode Tuning, vous avez accès aux caractéristiques du widget en temps réel :

• position du centroïde ;
• rapport signal-bruit (SNR) par segment ;
• franchissement des seuils par segment (noise threshold, finger threshold) ;
• tracé des signaux segment par segment…

Afin de démontrer les possibilités, on propose une petite application où la glissière sensitive reproduit le fonctionnement d’une roulette mécanique pour faire monter ou diminuer la valeur d’un compteur. Un afficheur à LED 7-segments (8 digits) rendra compte de la valeur du compteur en temps réel.

VIII-A. Design de l’application▲

En plus des deux blocs CapSense et EzI²C vus précédemment, les composants Timer et interrupt (isr) sont déposés dans la fenêtre de travail afin de cadencer l’acquisition des données de la glissière par interruption, 50 fois par seconde :

Avec l’horloge de 100 kHz, la période est réglée sur 20 ms et un signal d’interruption est déclenché en continu à chaque fin de comptage d’une période (Interrupts : On Terminal Count) :

L’API du composant Interrupt (nommé isr_timer ici) propose une fonction isr_timer_StartEx() et une macro CY_ISR pour configurer la table des vecteurs d’interruption avec l’adresse de la routine fournie en paramètre.

 

Sélectionnez

CY_ISR(myInterrupt) {   
    
     // Ici, le code de l’interruption

}

int main(void)
{
    CyGlobalIntEnable; /* autoriser les interruptions */

    /* Initialisation, démarrage */
    Timer_Start();
    isr_timer_StartEx(myInterrupt); /* myInterrupt, adresse de la routine d’interruption */

    // ...

}

De la sorte, la position du centroïde de la glissière est acquise toutes les 20 ms grâce à la fonction CapSense_GetCentroidPos() :

 

Sélectionnez

/* Code d'interruption */
CY_ISR(myInterrupt) { 
    if (! CapSense_IsBusy()){   /* Si acquisition CapSense terminée */
        flag = 1;                 /* On prévient le programme principal pour autres traitements */ 
        oldsliderval = sliderval; /* Sauvegarde de la position précédente du centroïde */
        sliderval = CapSense_GetCentroidPos(CapSense_LINEARSLIDER0__LS); /* Nouvelle position du centroide */
    }
}

Dans un deuxième onglet de la fenêtre TopDesign, on configure trois broches en sortie (Pin_DataIn, Pin_Clock, Pin_Latch) pour piloter l’afficheur à LED 7-segments. L’afficheur à LED 7-segments utilisé, acheté chez RobotDyn (101x19 mm), utilise deux registres à décalage 74HC595 chaînés pour piloter les 8 digits de l’afficheur.

VIII-B. Plan de brochage▲

Ci-dessous, la fenêtre de l’EDI PSoC Creator montrant le plan de brochage utilisé :

Mis à part les trois broches P0[0], P1[0] et P0[1] choisies et configurées pour piloter l’afficheur, les cinq autres broches configurées pour le capteur CapSense et le bloc de communication EzI²C correspondent aux connexions imposées par le matériel. Le bloc EzI²C n’est pas utilisé si le tuning du capteur CapSense est désactivé.

VIII-C. Gestion de l’afficheur▲

#include "led_display_7seg.h"
#include <stdio.h>

#define HIGH 1u
#define LOW  0u
                          
/*                            abcdefg(dp) */
const uint8 chiffre[10] =  {0b11111100, //0
                            0b01100000, //1
                            0b11011010, //2
                            0b11110010, //3
                            0b01100110, //4
                            0b10110110, //5
                            0b10111110, //6
                            0b11100000, //7
                            0b11111110, //8
                            0b11110110  //9
                           };                        
                            
const uint8 digit[8] = { 0b00001000, //SEG0
                         0b00000100, //SEG1
                         0b00000010, //SEG2
                         0b00000001, //SEG3
                         0b10000000, //SEG4
                         0b01000000, //SEG5
                         0b00100000, //SEG6
                         0b00010000  //SEG7
                       };

/* Décale un entier non signé (16 bits) d'un bit à la fois
   et alimente les deux registres à décalage 74HC595.
   Commence à partir du bit de poids faible. */
void shiftData(uint16 dataToShift)
{
    uint8 dataIndex = 0;
    Pin_Latch_Write(LOW); /* verrouillage */
    
    while (dataIndex < 16)
    {
        if (dataToShift & (1 << (dataIndex)))
        {
            Pin_DataIn_Write(HIGH);
        }
        else
        {
            Pin_DataIn_Write(LOW);
        }
        
        /* clock */
        Pin_Clock_Write(HIGH);
        Pin_Clock_Write(LOW);
        dataIndex++;
    }   
    /* Déverrouillage/latch */
    Pin_Latch_Write(HIGH);

}

/* Affichage d'un entier non signé 16 bits */
void led_display_7seg_Write(uint16 value) {
    uint8 i;
    char s[6];
    sprintf(s, "%hu", value);
    for (i = 0; i < sizeof(s); i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            shiftData( (digit[i] << 8) | (255 – chiffre[s[i] - '0']) );
        }
        else {
           shiftData( (digit[i] << 8) | (255 - 0b00000000) );
        }
    }
}

VIII-D. Programme principal▲

Le cœur du système est programmé comme une machine à états finis (finite state machine).

La glissière peut se trouver dans quatre états :

• STANDBY : aucune touche détectée, et en attente (état initial) ;
• TAP : touche détectée ;
• DRAG : mouvement axial sur la glissière détecté ;
• RELEASE : touche relâchée.

Les transitions entre états successifs sont programmées en comparant la position courante du centroïde (valeur NO_FINGER si aucune touche détectée, position du centroïde sinon entre 0 et 255) avec la position 20 ms plus tôt.

On donne le programme main.c complet :

main.c

Sélectionnez

#include "project.h"
#include "led_display_7seg.h"

/* Dé-commenter la ligne suivante pour activer le tuner */
//#define ENABLE_TUNER

#define NO_FINGER 0xFFFFu

enum state_capsense_t { STANDBY = 0, 
                        TAP, 
                        DRAG, 
                        RELEASE };
enum state_capsense_t state = STANDBY;
volatile uint16 sliderval = NO_FINGER;
volatile uint16 oldsliderval = NO_FINGER;
volatile uint8 flag = 0;
uint16 counter = 0;

/* Code d'interruption */
CY_ISR(myInterrupt) { 
    if (! CapSense_IsBusy()){   /* Si acquisition CapSense terminée */
        flag = 1;                 /* On prévient le programme principal pour autres traitements */ 
        oldsliderval = sliderval; /* Sauvegarde de la position précédente du centroïde */
        sliderval = CapSense_GetCentroidPos(CapSense_LINEARSLIDER0__LS); /* Nouvelle position du centroide */
    }
}

int main(void)
{
    CyGlobalIntEnable; /* autoriser les interruptions */

    /* Initialisation, démarrage */
    Timer_Start();
    isr_timer_StartEx(myInterrupt);  /* myInterrupt, adresse de la routine d’interruption */
    
    #ifdef ENABLE_TUNER
        CapSense_TunerStart();
    #else
        /* Démarrage, initialisation des baselines, et lancement du scan*/
        CapSense_Start();
        CapSense_InitializeAllBaselines();
        CapSense_ScanEnabledWidgets();
    #endif
      
    for(;;)
    {
        led_display_7seg_Write(counter); /* Affichage du compteur */
        if (flag) {
            flag = 0;
            #ifdef ENABLE_TUNER
                CapSense_TunerComm();
            #else
                /* mise à jour des baselines et relance du scan */
                CapSense_UpdateEnabledBaselines();
                CapSense_ScanEnabledWidgets();
            #endif
            
            uint16 oldpos = oldsliderval;
            uint16 newpos = sliderval;
            switch(state) {            
                case STANDBY:
                    if (newpos != NO_FINGER && oldpos == NO_FINGER){ 
                        state = TAP;
                    }
                    break;
            
                case TAP:
                    state = DRAG;
                    break;
            
                case DRAG:
                    if (newpos != NO_FINGER) {
                        counter += newpos - oldpos;
                    }
                
                    else if (newpos == NO_FINGER && oldpos != NO_FINGER){ 
                        state = RELEASE;
                    }
                    break;
            
                case RELEASE:
                    state = STANDBY;
                    break;
            
                default:
                    break;      
            }       
        }
    }
}

On peut activer le tuning du capteur CapSense en dé-commentant la ligne avec #define ENABLE_TUNER.

Bien entendu, l’implantation proposée ici n’est qu’une ébauche simpliste. Elle ne fait qu’incrémenter ou décrémenter la variable counter en fonction du déplacement du doigt sur la glissière, comme le montre la vidéo de démonstration ci-dessous, et rien de plus. Libre à vous de l’adapter pour faire monter ou descendre vos stores déroulants…

Démonstration CapSense PSoC 4

Dans cette autre démonstration ci-dessous, on se sert de la valeur du compteur pour contrôler la largeur d’impulsion d’un signal PWM qui va commander en rotation un servomoteur de modélisme :

Commande de servomoteur avec une glissière sensitive CapSense

Autour de sa technologie, Cypress propose des kits et des outils de développement. Ce tutoriel vous a montré comment mettre en œuvre rapidement un widget sensitif de type « glissière » (slider) sur une carte PSoC 4 dans l’EDI PSoC Creator. Le procédé SmartSense d’auto-tuning facilite le développement et la mise au point en ajustant automatiquement les paramètres du capteur et du firmware afin d’optimiser le rapport signal-bruit en toutes circonstances et éviter ainsi la détection de « fausses touches ».

La solution CapSense de détection capacitive trouve des utilisations dans une grande variété d’applications et de produits : électroménager, domotique, automobile, Internet des Objets, industrie, etc. Les boutons mécaniques classiques sont alors remplacés par des interfaces utilisateurs ergonomiques et changent la façon d’interagir avec les objets électroniques.

Enfin, si Arduino reste votre plateforme favorite, le module Grove - Capacitive Touch Slide Sensor offre une solution intéressante avec sa glissière axiale et ses deux boutons sensitifs.

Au dos de ce module sur la photo, une puce CY8C4014LQI, un processeur PSoC 4 de Cypress…

Pour finir, je remercie Vincent PETIT et ClaudeLELOUP pour leur travail de relecture.

• Getting Started with CapSense®
• PSoC® 4 and PSoC® 6 MCU CapSense® Design Guide
• PSoC 4 Capacitive Sensing (CapSense® CSD)
• CY8CKIT-041-41XX PSoC 4100S