Touch capacitivo con microcontrollore PIC16F886: 3 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

In questo tutorial esamineremo come è possibile utilizzare un microcontrollore PIC16F886 per rilevare le differenze di capacità, questo può essere successivamente utilizzato per sapere se viene premuto un touch pad. È bene avere familiarità con i microcontrollori pic prima di realizzare questo progetto.

Passaggio 1: collega il circuito

Innanzitutto, iniziamo collegando il circuito secondo lo schema sopra. Per realizzare il touch pad puoi piegare un foglio di alluminio in un quadrato e fissarlo su un filo. Puoi sperimentare con valori diversi per il resistore da 100k, ho scoperto che 100k ha funzionato bene per me.

Il pin RC4 viene utilizzato per iniziare a caricare/scaricare la capacità da misurare. C12IN0 è collegato al lato - di un comparatore interno e il pin C1IN è collegato al lato + dello stesso comparatore. Il microcontrollore vede la capacità come completamente carica quando la tensione C12IN0 supera la tensione C1IN. Il partitore di tensione resistivo assicura che C1IN sia vicino a 5 volt.

Poiché il touch pad dipende dalla presenza di una capacità significativa tra te e la massa del circuito, è possibile che una batteria non funzioni.

Passaggio 2: il file di intestazione

Finito con tutti i collegamenti? Bene, procederemo con il file di intestazione. Utilizzeremo il compilatore XC8 e, come suggerisce il titolo, dovrai creare un nuovo file di intestazione nel tuo progetto e copiare e incollare il codice seguente. Puoi anche copiarlo e incollarlo sopra il codice principale senza alcun file di intestazione.

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

conteggio int;

int calibrazioneValue, maxCalibrationValue, minCalibrationValue;

int getChargeTime(){

int conteggio timer = 0; int overflowCount = 0; //capacità di scarica da misurare RC4 = 0; _delay_ms(DISCHARGE_TIME); //dare un ritardo sufficiente per scaricare completamente (quasi completamente) il "condensatore" //cancellare il flag di overflow del timer T0IF = 0; //aspetta che il timer trabocchi, inizia il conteggio da 0 while(!T0IF); T0SE = 0; //inizia la capacità di carica da misurare RC4 = 1; //aspetta che la capacità si carichi fino alla tensione di riferimento while(C1OUT){ timerCount = TMR0; if(T0IF){ overflowCount++; T0SE = 0; } } count = (256 * overflowCount) + timerCount; //reimposta conteggio timer conteggio timer = 0; overflowCount = 0; conteggio dei resi; }

int isTouching(int tolerance){

//media di più campioni doppia media = 0; for(int i = 0; i calibrazioneValore + tolleranza) media++; } media /= TOUCH_SAMPLE; //media sarà un numero compreso tra 0 e 1 if(media > 0.2) return 1; restituisce 0; }

void calibra(){

int media = 0; int campioni[CALIBRATION_SAMPLE]; // ottiene il valore medio per (int i = 0; i < CALIBRATION_SAMPLE; i++){ campioni = getChargeTime(); media += campioni; } media /= CALIBRATION_SAMPLE; valore di calibrazione = media; // ottiene i valori max/min maxCalibrationValue = sample[0]; minCalibrationValue = campioni[0]; for(int i = 0; i maxCalibrationValue) maxCalibrationValue = campioni; if(samples < minCalibrationValue) minCalibrationValue = sample; } }

void setupCapacitiveTouch(){

//impostando il pin di carica/scarica come output, in questo caso è RC4 TRISCbits. TRISC4 = 0; //impostazione del timer0 T0CS = 0; PSA = 1; //configurazione comparatore C1CH0 = 0; C1CH1 = 0; C1R = 0; C1ON = 1; C1POL = 0; //cancellazione dei valori di conteggio count = 0; //cancellazione dei valori di calibrazione calibrazioneValue = 0; maxCalibrationValue = 0; minCalibrationValue = 0; //esegui la calibrazione all'avvio calibrate(); }

Passaggio 3: scrittura del codice principale

A partire dal codice principale, dovrai includere il file di intestazione creato nel passaggio precedente. Il codice seguente è un esempio di come è possibile utilizzare la funzione isTouching come interruttore. Nel mio caso ho dato all'intestazione il nome capacitiveTouch.h.

#includere

#include "capacitiveTouch.h"

// questa variabile dice se il pulsante è o non è già premuto

int ultimoStato = 0;

vuoto principale(){

//imposta RC5 come output TRISCbits. TRISC5 = 0; //è necessario richiamare questa funzione all'avvio del programma setupCapacitiveTouch(); _delay_ms(1000); //calibrate dopo l'esatta configurazione calibrate(); while(1){ //verifica se il pulsante viene premuto if(isTouching(15) && lastState == 0){ if(RC5) RC5 = 0; altrimenti RC5 = 1; ultimoStato = 1; } //verifica se il pulsante viene rilasciato else if(lastState == 1 && !isTouching(15)) lastState = 0; _delay_ms(20); } }

calibrare:

Quando questa funzione viene chiamata, le variabili calibrazioneValue, maxCalibrationValue e minCalibrationValue verranno aggiornate. calibrazioneValue è utilizzato dalla funzione isTouching. Tieni presente che il touch pad deve essere lasciato solo durante la calibrazione.

configurazioneCapacitiveTouch:

Deve essere chiamato all'inizio del programma. Imposta i bit necessari utilizzati dalle altre funzioni. Esegue anche una calibrazione. Tuttavia ho ottenuto risultati migliori aspettando un secondo ed eseguendo nuovamente la calibrazione separatamente.

è toccante:

Questa funzione restituisce 1 se rileva un aumento di capacità sul C12IN0 e restituisce 0 se la capacità è vicina a quella che era durante la calibrazione. In parole povere, se qualcuno tocca il pad, la funzione isTouching restituirà 1. La funzione vuole anche un parametro come input, questa è la tolleranza per l'attivazione. Più alto è il valore di tolleranza, meno sensibile diventa. Nella mia configurazione ho trovato che 15 ha funzionato bene, ma poiché questo dipende dalla frequenza dell'oscillatore e da quanta capacità viene aggiunta quando lo premi, dovresti sperimentare con questo valore finché non trovi qualcosa che funzioni per te.

getChargeTime:

Quando vuoi sapere quanto tempo ci vorrebbe per caricare la capacità alla tensione CVREF, questa funzione la testerà e restituirà un numero intero. Per ottenere il tempo in secondi si utilizza questa formula: (4 * getChargeTime) / oscillatorFrequency = chargeTimeInSeconds Questa formula può essere utilizzata anche per ottenere l'input di tolleranza dalla funzione isTouching in secondi.