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

Débuter avec une glissière sensitive CapSense dans l'EDI PSoC Creator

f-leb

La technologie CapSense pour les boutons sensitifs à détection capacitive brevetée par Cypress a élevé le fabricant de semi-conducteurs parmi les leaders du marché dans le domaine, et offre une ergonomie nouvelle face aux boutons et touches mécaniques. Dans cet article, on propose de découvrir comment mettre en œuvre cette technologie sur une carte embarquée PSoC 4 dans l’EDI (Environnement de Design Intégré) PSoC Creator. Une démonstration est effectuée avec une glissière (slider) à touches sensitives qui incrémente ou décrémente un compteur d’un simple effleurement du doigt.

Commentez

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

- Auteur : f-leb

- Parution : 19 novembre 2019

- Mise à jour : 30 novembre 2019

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2019 f-leb. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Voir également :

- 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

Sommaire

- I. Introduction : les kits Cypress PSoC et l’EDI PSoC Creator

- II. Les boutons mécaniques vs boutons sensitifs

- III. Technologie CapSense

- IV. Les touches sensitives dans les kits Cypress PSoC

- V. Réglage et optimisation des performances (tuning)

- VI. Les Widgets CapSense

- VII. L’API CapSense dans PSoC Creator

- VIII. Exemple d’utilisation

- VIII-A. Design de l’application

- VIII-B. Plan de brochage

- VIII-C. Gestion de l’afficheur

- VIII-D. Programme principal

- IX. Conclusion

- X. Annexe - Documentation Cypress

I - Introduction : les kits Cypress PSoC et l’EDI PSoC Creator

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.

PSoC, une puce programmable et configurable selon Cypress

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

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.

Dans la famille des PSoC 4, le PSoC 4200 avec contrôleur CapSense - Image Cypress

II - Les boutons mécaniques vs boutons sensitifs

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.

Télécommande démontée, quatre boutons-poussoirs mécaniques sont soudés sur la carte.

À 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 :

Schéma de principe du système CapSense - Image Cypress

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.

Technologie CapSense : des boutons sensitifs à détection capacitive équipant une machine à laver – Image Cypress

III - Technologie CapSense

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

Détection capacitive : lorsqu’un objet conducteur est placé à proximité des deux électrodes, la capacité parasite initiale augmente et peut être détectée.

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) :

Schéma-bloc simplifié CapSense Sigma-Delta (CSD) – Image Cypress

Par exemple, quand le doigt s'approche du capteur, la capacité CS 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 :

Monitoring de la sortie du capteur capacitif - Image Cypress

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.

IV - Les touches sensitives dans les kits Cypress PSoC

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 :

Kit CY8CKIT-044

Détection de mouvement axial ou circulaire

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 :

Capteur de proximité CapSense avec le kit CY8CKIT-044 – Image Cypress

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 :

PSoC 4100S dans le boîtier du kit – Image Cypress

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é :

Circuit avec surface sensitive (Flex PCB) à raccorder à la carte PSoC 4100S– Image Cypress

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 :

Application du film personnalisé – Image Cypress

Une application « Hello World » avec une interface tactile de sélection de couleur d’une LED – Image Cypress

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.

V - Réglage et optimisation des performances (tuning)

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.

État du capteur dans PSoC Creator : en l'absence de toucher, les données du capteur peuvent légèrement dériver (en bleu). Dans ce cas, la référence (baseline en violet) est progressivement ajustée, et le signal résultant est nul (courbe du bas).

État du capteur dans PSoC Creator : quand le seuil de bruit est franchi, c'est qu'un corps s'approche. La baseline est alors maintenue constante à son niveau détecté juste avant le franchissement du seuil.

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.

Le SNR (Signal-to-noise Ratio = SIGNAL/NOISE) doit être maintenu à un niveau suffisant, quelles que soient les perturbations extérieures.

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 annexe, en particulier le CapSense Design Guide).

VI - Les Widgets CapSense

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.

Configuration des Widgets dans PSoC Creator : boutons simples, matrice de boutons, glissière radiale ou axiale, 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]) :

Cinq segments en double chevron imbriqués forment une glissière axiale.

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 :

Évolution idéale des signaux et de la position du centre de l’aire de contact (centroïde) lors du parcours de la glissière avec le doigt – Image Cypress

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).

L'aire de contact est principalement sur le segment 2, mais aussi à cheval sur les segments adjacents 1 et 3 – Image Cypress

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.

Évaluation de la position du centroïde

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 :

VII - L’API CapSense dans PSoC Creator

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^2C. 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^2C 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…

Visualisation en temps réel de la position du centroïde, courbes des signaux, franchissement des seuils…

En mode « Tuning », visualisation de la position du centroïde en temps réel dans l'EDI PSoC Creator.

VIII - Exemple d’utilisation

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.

Un compteur qui défile en augmentant ou en diminuant selon le mouvement du doigt sur la glissière.

VIII-A - Design de l’application

En plus des deux blocs CapSense et EzI^2C 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.

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() :

/* 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.

Dans PSoC Creator, trois broches de sortie supplémentaires DataIn, Clock et Latch pour piloter l'afficheur.

Afficheur à LED 8 digits 7-segments de RobotDyn. Au dos de la carte, deux registres à décalage 74HC595.

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^2C correspondent aux connexions imposées par le matériel. Le bloc EzI^2C n’est pas utilisé si le tuning du capteur CapSense est désactivé.

Extrait schémas CapSense CY8CKIT-042

VIII-C - Gestion de l’afficheur

Le système d’affichage n’est pas à proprement parler l’objectif de ce tutoriel. Même si l’afficheur 7-segments employé ici est très efficace par sa taille et sa luminosité, et pour un coût très modique, on aurait pu tout aussi bien utiliser un afficheur LCD, voire rendre compte des valeurs dans un terminal série.

À toutes fins utiles, on donne le code de pilotage de l’afficheur à LED. Le lecteur se reportera à la documentation de la société RobotDyn pour plus de détails sur les caractéristiques de cet afficheur.

led_display_7seg.c

#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) );
}
}
}

La fonction led_display_7seg_Write() proposée permet ainsi l’affichage d’un entier 16 bits non signé entre 0 et 65535. Attention, le fonctionnement de l’afficheur est multiplexé. Chaque digit est affiché tour à tour, il faut donc compter sur la persistance rétinienne et relancer régulièrement la fonction led_display_7seg_Write().

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

#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…

Animation en format "youtube" non supportée.
Contenu uniquement consultable en ligne à cette adresse :
https://www.youtube.com/watch?v=cukWg1gsCV4

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 :

Génération d'un signal PWM dans PSoC Creator pour commander la rotation du servomoteur.

Animation en format "youtube" non supportée.
Contenu uniquement consultable en ligne à cette adresse :
https://www.youtube.com/watch?v=RyX8x0tFGKc

IX - Conclusion

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.

Module Grove - Capacitive Touch Slider Sensor

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.

X - Annexe - Documentation Cypress

- Getting Started with CapSense®

- PSoC® 4 and PSoC® 6 MCU CapSense® Design Guide

- PSoC 4 Capacitive Sensing (CapSense® CSD)

- CY8CKIT-041-41XX PSoC 4100S