Toucher capacitif avec microcontrôleur PIC16F886 : 3 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Dans ce didacticiel, nous verrons comment utiliser un microcontrôleur PIC16F886 pour détecter les différences de capacité, cela peut être utilisé plus tard pour savoir si un pavé tactile est enfoncé. Il est bon de se familiariser avec les microcontrôleurs pic avant de réaliser ce projet.

Étape 1: câblez votre circuit

Tout d'abord, commençons par câbler le circuit selon le schéma ci-dessus. Pour fabriquer le pavé tactile, vous pouvez plier une feuille d'aluminium en un carré et du ruban adhésif sur un fil. Vous pouvez expérimenter avec différentes valeurs pour la résistance 100k, j'ai trouvé que 100k fonctionnait bien pour moi.

La broche RC4 est utilisée pour commencer à charger/décharger la capacité à mesurer. C12IN0 est connecté au côté - d'un comparateur interne et la broche C1IN est connectée au côté + du même comparateur. Le microcontrôleur considère que la capacité est complètement chargée lorsque la tension C12IN0 dépasse la tension C1IN. Le diviseur de tension résistif garantit que C1IN est proche de 5 volts.

Étant donné que le pavé tactile dépend d'une capacité importante entre vous et la terre du circuit, il est possible qu'une batterie ne fonctionne pas.

Étape 2: Le fichier d'en-tête

Fini toutes les connexions ? Bien, nous allons procéder avec le fichier d'en-tête. Nous utiliserons le compilateur XC8 et, comme le titre l'indique, vous allez maintenant créer un nouveau fichier d'en-tête dans votre projet et copier-coller le code suivant. Vous pouvez tout aussi bien le copier-coller au-dessus de votre code principal sans aucun fichier d'en-tête.

#define CALIBRATION_SAMPLE 20#define TOUCH_SAMPLE 10 #define DISCHARGE_TIME 5

nombre entier;

int calibrationValue, maxCalibrationValue, minCalibrationValue;

int getChargeTime(){

int timerCount = 0; int overflowCount = 0; //capacité de décharge à mesurer RC4 = 0; _delay_ms(DISCHARGE_TIME); //donne un délai suffisant pour décharger complètement (presque complètement en fait) le "condensateur" //effacer l'indicateur de dépassement du temporisateur T0IF = 0; // attend que le timer déborde, démarre le décompte à partir de 0 while(!T0IF); T0IF = 0; //commencer à charger la capacité à mesurer RC4 = 1; //attendre que la capacité se charge jusqu'à la tension de référence while(C1OUT){ timerCount = TMR0; if(T0IF){ overflowCount++; T0IF = 0; } } count = (256 * overflowCount) + timerCount; //réinitialiser timerCount timerCount = 0; overflowCount = 0; nombre de retours; }

int estTouchant(int tolérance){

//moyenne de plusieurs échantillons double moyenne = 0; for(int i = 0; i valeur d'étalonnage + tolérance) moyenne++; } moyenne /= TOUCH_SAMPLE; //moyenne sera un nombre entre 0 et 1 if(average > 0.2) return 1; renvoie 0; }

annuler calibrer(){

moyenne entière = 0; int échantillons[CALIBRATION_SAMPLE]; // obtenir la valeur moyenne pour (int i = 0; i < CALIBRATION_SAMPLE; i++){ samples = getChargeTime(); moyenne += échantillons; } moyenne /= CALIBRATION_SAMPLE; valeur d'étalonnage = moyenne; //obtenir les valeurs max/min maxCalibrationValue = samples[0]; minCalibrationValue = échantillons[0]; for(int i = 0; i maxCalibrationValue) maxCalibrationValue = échantillons; if(samples < minCalibrationValue) minCalibrationValue = samples; } }

void setupCapacitiveTouch(){

//définir la broche de charge/décharge comme sortie, dans ce cas c'est RC4 TRISCbits. TRISC4 = 0; //configuration du timer0 T0CS = 0; ASP = 1; //configuration du comparateur C1CH0 = 0; C1CH1 = 0; C1R = 0; C1ON = 1; C1POL = 0; //effacement des valeurs de comptage count = 0; //effacement des valeurs d'étalonnage calibrationValue = 0; valeurCalibrationmax = 0; minValeurEtalonnage = 0; //exécuter le calibrage au démarrage calibrer(); }

Étape 3: Rédaction du code principal

En commençant par le code principal, vous devrez inclure le fichier d'en-tête créé à l'étape précédente. Le code suivant est un exemple d'utilisation de la fonction isTouching comme interrupteur. Dans mon cas, j'ai donné à l'en-tête le nom capacitiveTouch.h.

#comprendre

#include "capacitiveTouch.h"

// cette variable indique si le bouton est ou n'est pas déjà enfoncé

int dernier état = 0;

void main(){

//définir RC5 comme sortie TRISCbits. TRISC5 = 0; //vous devez appeler cette fonction au démarrage du programme setupCapacitiveTouch(); _delay_ms(1000); //calibrer après votre configuration exacte calibrer(); while(1){ //vérification si le bouton est pressé if(isTouching(15) && lastState == 0){ if(RC5) RC5 = 0; sinon RC5 = 1; dernier état = 1; } //vérification si le bouton est relâché else if(lastState == 1 && !isTouching(15)) lastState = 0; _delay_ms(20); } }

étalonner:

Lorsque cette fonction est appelée, les variables calibrationValue, maxCalibrationValue et minCalibrationValue seront mises à jour. calibrationValue est utilisé par la fonction isTouching. Gardez à l'esprit que le pavé tactile doit être laissé seul pendant l'étalonnage.

setupCapacitifTouch:

Doit être appelé au début de votre programme. Il met en place les bits nécessaires utilisés par les autres fonctions. Il effectue également un étalonnage. Cependant, j'ai obtenu de meilleurs résultats en attendant une seconde et en exécutant à nouveau l'étalonnage séparément.

estToucher:

Cette fonction retourne 1 si elle détecte une augmentation de capacité sur le C12IN0 et retourne 0 si la capacité est proche de celle qu'elle était lors de la calibration. En termes simples, si quelqu'un touche le pad, la fonction isTouching renverra 1. La fonction veut également un paramètre comme entrée, c'est la tolérance pour qu'elle se déclenche. Plus la valeur de tolérance est élevée, moins elle devient sensible. Dans ma configuration, j'ai trouvé que 15 fonctionnaient bien, mais comme cela dépend de la fréquence de l'oscillateur et de la capacité ajoutée lorsque vous appuyez dessus, vous devriez expérimenter avec cette valeur jusqu'à ce que vous trouviez quelque chose qui fonctionne pour vous.

getChargeTime:

Lorsque vous voulez savoir combien de temps il faudrait pour charger la capacité à la tension CVREF, cette fonction la testera et renverra un entier. Pour obtenir le temps en secondes, vous utilisez cette formule: (4 * getChargeTime) / oscillatorFrequency = chargeTimeInSeconds Cette formule peut également être utilisée pour obtenir l'entrée de tolérance de la fonction isTouching en secondes.