Assemblare un sensore capacitivo con Arduino
Questa lezione è dedicata all’assemblaggio e alla programmazione di una versione semplificata del circuito capacitivo composto da 1 solo sensore, al fine di comprendere meglio il funzionamento del codice.
Il circuito è costituito dai seguenti componenti:
- 1 board Arduino UNO
- una resistenza da 1 Mega Ohm (in alternativa va bene anche un valore tra 800 kOhm e 5 MOhm)
- 1 breadboard
- cavetti
- (opzionale) pezzi di carta stagnola
Le componenti del circuito elettronico sono estremamente semplici da reperire e facili da assemblare: basta collegare il pin trasmettitore con una riga della basetta, il pin ricevitore con un’altra riga, e collegare le righe tra loro con la resistenza.
Per convezione, scegli il PIN digitale 13 come trasmettitore, e il PIN digitale 2 come ricevitore.
Il collegamento con l’elemento conduttivo di contatto va posto nella riga del pin ricevitore. Per semplificare, come elemento conduttivo di contatto utilizza un pezzo di carta stagnola; nelle lezioni finali, utilizzerai la stampa 3D conduttiva. In mancanza di carta stagnola, per il test puoi toccare l’estremità del cavo se scoperta dalla guaina isolante.
Una volta assemblato il circuito, sei pronto per programmarlo.
Il codice si basa sulla libreria opensource CapacitiveSensor sviluppata da Paul Badger. La libreria è già integrata tra quelle di default che puoi scaricare con l’Arduino IDE, pertanto non hai bisogno di scaricarla dal repository GitHub. Puoi trovare maggiori informazioni sul sito di Arduino Playground.
Come primo passo, dichiara l’inclusione della libreria nel codice
#include <CapacitiveSensor.h>
Per creare l’istanza del sensore capacitivo e inizializzare i PIN ricevitore e trasmettitore, richiama il metodo CapacitiveSensor, la cui sintassi è
CapacitiveSensor CapacitiveSensor(byte pinTrasmittente, byte pinRicevitore)
Come detto, scegli i PIN 13 e 2
CapacitiveSensor capSensor = CapacitiveSensor(13, 2);
Nella funzione setup di Arduino, hai bisogno di aprire una connessione Seriale, scegliendo un baudrate di 9600 . In questo test utilizzerai la connessione Seriale per comunicare con il PC via USB e stampare in tempo reale le modifiche della capacitanza (e quindi capire se il sensore è stato toccato o meno).
void setup() {
Serial.begin(9600);
}
Infine, crea il codice del loop
void loop() {
// memorizza in una variable il valore riportato dal sensore
long sensorValue = capSensor.capacitiveSensor(30);
// stampa il valore del sensore
Serial.println(sensorValue);
// per rendere leggibile il flusso, mettiamo un ritardo di 50 millisecondi
delay(50);
}
Nel loop stai utilizzando un altro metodo della libreria inclusa, ovvero capacitiveSensor, la cui sintassi è
long capacitiveSensor(byte risoluzione)
Il valore numerico rappresenta la risoluzione che si desidera impostare: più è alta la risoluzione, più sarà preciso il sensore ma maggiore sarà il tempo di risposta. Il valore 30 è un buon valore mediano.
Attenzione alle maiuscole, la differenza con il precedente metodo consiste unicamente nella prima lettera maiuscola!
Per concludere il primo codice, è necessario prendere il valore del sensore e stamparlo (println) in Seriale.
Come riepilogo, il codice completo è:
#include <CapacitiveSensor.h>
CapacitiveSensor capSensor = CapacitiveSensor(13, 2);
void setup() {
Serial.begin(9600);
}
void loop() {
// memorizza in una variable il valore riportato dal sensore
long sensorValue = capSensor.capacitiveSensor(30);
// stampa il valore del sensore
Serial.println(sensorValue);
// per rendere leggibile il flusso, mettiamo un ritardo di 50 millisecondi
delay(50);
}
Puoi scaricare questo codice completo in formato .ino per IDE Arduino o Eclipse.
Non resta che connettere la scheda UNO al PC e caricare il codice completo, dopodiché aprire un monitor seriale con l’Arduino IDE (o il software equivalente che si sta utilizzando).
Apparirà una schermata come questa:
I valori numerici rappresentano la capacitanza, e se non sono presenti corpi estranei in prossimità del circuito e del sensore, si nota che:
- vengono stampati con una frequenza costante, rappresentata dal valore di delay dichiarato (50ms)
- rientrano in un range di valori compreso tra 0 a 150 circa
Avvicina le dita all’estremità del cavetto che utilizziamo da sensore. Se hai applicato all’estremità della carta stagnola o altro materiale conduttivo, è sufficiente il tocco, altrimenti è consigliabile afferrare l’estremità scoperta:
Il comportamento che noterai nel monitor seriale sarà simile a questo:
Quando toccherai l’estremità conduttiva, il circuito stamperà dei valori con nuove caratteristiche:
- valori molto più alti, tra 10.000 e 60.000
- il valore aumenta ulteriormente se aumentiamo la superficie di contatto con il sensore (palmo aperto al posto del dito) oppure se impugnamo con maggiore intensità
- vengono stampati con un ritardo maggiore rispetto a quanto dichiarato dal delay e quindi alla situazione senza interferenza
- il ritardo è proporzionale al valore stampato, cioè alla superficie di contatto
Una volta compreso il funzionamento dei due metodi principali della libreria Capacitive, cioè CapacitiveSensor() e capacitiveSensor(), puoi creare un nuovo script per realizzare un pulsante capacitivo. Rispetto al precedente script, aggiungi un valore di soglia per sensorValue, superato il quale si può affermare che il sensore è stato toccato. Hai notato che con sensorValue < 100, il circuito è in riposo. Con sensorValue > 10.000, il sensore è decisamente toccato.
Imposta come test un valore di 500. Dichiara la soglia in cima al nostro programma, sotto all’include della libreria:
int threshold = 500;
All’interno del loop, al posto di stampare il valore del sensore, inserisci una condizione di superamento della soglia e, all’interno, l’azione che viene effettuata se superata la soglia:
// verifico se il valore del sensore capacitivo ha superato la soglia,
// cioè se è stato toccato
if(sensorValue > threshold){
//azione di soglia di hi-Storia:
//associamo a questo sensore l'ID 1
Serial.println(1);
// inserisci qui sotto ulteriori azioni
// fine azioni di soglia
}
Nel dispositivo hi-Storia, ogni sensore viene associato un ID, che viene inviato via USB in risposta al tocco del relativo sensore. In questo modo viene restituito un valore unico per ogni sensore, valore che sarà interpretato dall’applicazione player per lanciare un file audio relativo all’ID specifico.
Opzionalmente, in aggiunta alla stampa Seriale dell’ID puoi eseguire qualsiasi altra azione, come accendere un LED o azionare un motore.
Il codice completo del pulsante capacitivo risulta:
#include <CapacitiveSensor.h>
CapacitiveSensor capSensor = CapacitiveSensor(13, 2);
int threshold = 500;
void setup() {
Serial.begin(9600);
}
void loop() {
// memorizza in una variable il valore riportato dal sensore
long sensorValue = capSensor.capacitiveSensor(30);
// verifico se il valore del sensore capacitivo ha superato la soglia,
// cioè se è stato toccato
if(sensorValue > threshold){
//associamo a questo sensore l'ID 1
Serial.println(1);
}
delay(50);
}
Caricando questo software e toccando il sensore, verrà stampato unicamente l’ID. Quando il sensore non ha interferenze, Arduino non esegue nulla e rimane in attesa.
Se ci sono problemi nella visualizzazione dell’ID, prova a cambiare la soglia (abbassandola fino a 200 unità).
Nella prossima lezione lavorerai con più sensori e con le relative ottimizzazioni di codice.
Puoi scaricare questo codice completo in formato .ino per IDE Arduino o Eclipse.