Progettiamo un sensore di capacità DIY per Arduino

Post Views: 1,594

Creiamo un sensore di capacità per Arduino e usiamolo come interruttore di prossimità nei nostri progetti.

I sensori capacitivi rilevano i cambiamenti nei campi elettromagnetici. Ogni esemplare vivente ha un campo elettromagnetico, anche noi. I sensori capacitivi sono estremamente utili perché possono rilevare il contatto umano e ignorare altri fattori ambientali. Probabilmente conosciamo tutti i sensori capacitivi di fascia alta, perché sono presenti in quasi tutti gli smartphone, ma in realtà sono in circolazione dalla fine degli anni ’20. Esistono kit Arduino con sensori capacitivi, come le tastiere tattili capacitive, che è possibile collegare facilmente. Ma è altrettanto facile creare i propri sensori capacitivi con un Arduino e un’antenna.

Valutazioni

Complessità: poiché tutto ciò che serve è un’antenna, si può essere abbastanza creativi con ciò che è l’antenna e dove è posizionata. Brevi pezzi di filo o nastro di rame sono ottimi per semplici sensori tattili. Il pezzo di nastro di rame diventa improvvisamente un interruttore tattile, il che significa che non è nemmeno necessario un pulsante per ottenere la stessa funzionalità. Se l’antenna è costituita da una bobina di filo o da un pezzo di pellicola, è possibile estendere la portata del sensore oltre il tocco, noto come sensore capacitivo proiettato. Ciò significa che è possibile rilevare la mano di una persona a diversi centimetri di distanza dall’antenna, ideale per nascondere i sensori dietro altri materiali.

Costo: un kit touch capacitivo progettato per uno scopo specifico costa tra i 10 ed i 30 euro. Il kit dovrebbe svolgere bene il suo lavoro, ma sarà limitato al design dell’interfaccia. L’opzione più economica è utilizzare la libreria CapSense per Arduino, che permette di realizzare un sensore capacitivo con un’antenna e senza hardware aggiuntivo.

Dove: i sensori tattili capacitivi possono funzionare con qualsiasi metallo conduttivo, quindi se si riesce a progettare un oggetto esterno in metallo, l’unico lavoro sarà quello di collegare quell’oggetto ad Arduino. Inoltre è sempre possibile utilizzare legno o una stampante 3D per creare un involucro che nasconda l’antenna senza bloccarne le capacità ricettive.

Il modo più semplice per realizzare un sensore capacitivo è utilizzare la libreria CapSense di Paul Badger. Utilizzando tale libreria è possibile eliminare del tutto gli interruttori meccanici e sostituirli con sensori tattili capacitivi altamente robusti o rilevatori di presenza capacitivi.

Implementiamo lo sketch CapPinSketch

Innanzi tutto presentiamo la lista del materiale che ci occorre per il progetto:

Arduino Uno o equivalente
Un’antenna (un pezzo di filo conduttore, o un cavo di collegamento)
Pinzette a coccodrillo (opzionali)

Come è evidente dalla foto, è necessario pochissimo lavoro.
Si può semplicemente avere un’antenna a filo collegata al pin 5 ed incrementarne la portata collegandolo a qualsiasi altra superficie conduttiva. Le clip a coccodrillo sono utili per agganciare antenne diverse (ed avere quindi sensibilità diverse) in modo facile e veloce.

Se la libreria CapSense viene riconosciuta correttamente, al suo interno è possibile trovare la cartella degli esempi. Carichiamo la libreria, quindi scegliamo File->Esempi->CapSense->Esempi->CapPinSketch dal menu Arduino per caricare lo sketch.

#include <CapPin.h>

/* CapPin
 * Capacitive Library CapPin Demo Sketch
 * Paul Badger 2011
 * This class uses the bullt-in pullup resistors read the capacitance on a pin
 * The pin is set to input and then the pullup is set,
 * A loop times how long the pin takes to go HIGH.
 * The readPin method is fast and can be read 1000 times in under 10 mS.
 * By reading the pin repeated you can sense "hand pressure" 
 * at close range with a small sensor. A larger sensor (piece of foil/metal) will yield
 * larger return values and be able to sense at more distance. For 
 * a more senstive method of sensing pins see CapTouch
 * Hook up a wire with or without a piece of foil attached to the pin.
 * I suggest covering the sensor with mylar, packing tape, paper or other insulator
 * to avoid having users directly touch the pin. 
 */
 
CapPin cPin_5 = CapPin(5);   // read pin 5

float smoothed;

void setup()                    
{

  Serial.begin(115200);
  Serial.println("start");
 // slider_2_7.calibrateSlider();

}

void loop()                    
{


  delay(1);
  long total1 = 0;
  long start = millis();
  long total =  cPin_5.readPin(2000);


  // simple lowpass filter to take out some of the jitter
  // change parameter (0 is min, .99 is max) or eliminate to suit
  smoothed = smooth(total, .8, smoothed);   

  Serial.print( millis() - start);      // time to execute in mS
  Serial.print("\t");
  Serial.print(total);                  // raw total
  Serial.print("\t");
  Serial.println((int) smoothed);       // smoothed
  
  delay(5);                       
}

// simple lowpass filter
// requires recycling the output in the "smoothedVal" param
int smooth(int data, float filterVal, float smoothedVal){

  if (filterVal > 1){      // check to make sure param's are within range
    filterVal = .999999;
  }
  else if (filterVal <= 0){
    filterVal = 0;
  }

  smoothedVal = (data * (1 - filterVal)) + (smoothedVal  *  filterVal);

  return (int)smoothedVal;
}

#include <CapPin.h>

/* CapPin

* Capacitive Library CapPin Demo Sketch

* Paul Badger 2011

* This class uses the bullt-in pullup resistors read the capacitance on a pin

* The pin is set to input and then the pullup is set,

* A loop times how long the pin takes to go HIGH.

* The readPin method is fast and can be read 1000 times in under 10 mS.

* By reading the pin repeated you can sense "hand pressure"

* at close range with a small sensor. A larger sensor (piece of foil/metal) will yield

* larger return values and be able to sense at more distance. For

* a more senstive method of sensing pins see CapTouch

* Hook up a wire with or without a piece of foil attached to the pin.

* I suggest covering the sensor with mylar, packing tape, paper or other insulator

* to avoid having users directly touch the pin.

CapPin cPin_5 = CapPin(5); // read pin 5

float smoothed;

void setup()

{

Serial.begin(115200);

Serial.println("start");

// slider_2_7.calibrateSlider();

}

void loop()

{

delay(1);

long total1 = 0;

long start = millis();

long total = cPin_5.readPin(2000);

// simple lowpass filter to take out some of the jitter

// change parameter (0 is min, .99 is max) or eliminate to suit

smoothed = smooth(total, .8, smoothed);

Serial.print( millis() - start); // time to execute in mS

Serial.print("\t");

Serial.print(total); // raw total

Serial.print("\t");

Serial.println((int) smoothed); // smoothed

delay(5);

}

// simple lowpass filter

// requires recycling the output in the "smoothedVal" param

int smooth(int data, float filterVal, float smoothedVal){

if (filterVal > 1){ // check to make sure param's are within range

filterVal = .999999;

}

else if (filterVal <= 0){

filterVal = 0;

}

smoothedVal = (data * (1 - filterVal)) + (smoothedVal * filterVal);

return (int)smoothedVal;

}

Premiamo quindi il pulsante Compila per controllare il codice. La compilazione mette in evidenza qualsiasi errore di sintassi, che si illumina in rosso quando viene scoperto. Se lo sketch
compila correttamente, facciamo clic su Carica per inviarlo alla scheda. Quando è terminato il caricamento, apriamo il monitor seriale e tocchiamo o avviciniamoci all’antenna: dovremmo vedere due valori che scorrono lungo lo schermo. A sinistra c’è il valore esatto che viene letto; a destra è la stessa lettura dopo il livellamento.

Se non succede nulla,

Ricontrollare il cablaggio:
Assicurrsi di utilizzare il numero pin corretto.
Controllare i collegamenti sulla breadboard.

Come funziona il programma

Il programma è estremamente semplice: dopo aver caricato la libreria, definiamo il pin 5 come CapPin, ed un valore float (smoothed) che utilizzeremo per stabilizzare il valore letto ed eliminare il rumore di fondo. Nel Setup() provvederemo ad inizializzare la seriale, mentre nel Loop() viene eseguita la letura dei valori capacitivi dell’antena. Le letture vengono poi sottoposte a controllo per filtrare ed eliminare tutti i valori che risultano al di fuori della soglia di intervento richiesta.

Cambiando la lunghezza del filo, la superficie collegata o il valore di filtraggio è possibile tarare lo strumento per renderlo rispondente alle nostre esigenze.

Considerazioni finali

Basta un filo ed il nostro fido Arduino per creare un sensore di capacità per Arduino e condurre esperimenti interessanti, economici e flessibili.

Se avete domande o consigli in merito a progetti simili, non esitate a scriverci: moreware@moreware.org.

Luigi_Morelli

Definire ciò che si è non risulta mai semplice o intuitivo, in specie quando nella vita si cerca costantemente di migliorarsi, di crescere tanto professionalmente quanto emotivamente. Lavoro per contribuire al mutamento dei settori cardine della computer science e per offrire sintesi ragionate e consulenza ad aziende e pubblicazioni ICT, ma anche perche’ ciò che riesco a portare a termine mi dà soddisfazione, piacere. Così come mi piace suonare (sax, tastiere, chitarra), cantare, scrivere (ho pubblicato 350 articoli scientfici e 3 libri sinora, ma non ho concluso ciò che ho da dire), leggere, Adoro la matematica, la logica, la filosofia, la scienza e la tecnologia, ed inseguo quel concetto di homo novus rinascimentale, cercando di completare quelle sezioni della mia vita che ancora appaiono poco ricche.