Cap-Pad (abbreviazione di Capacitive Pad) è il prototipo di una superficie di controllo basata su Arduino e sull’uso di sensori capacitivi realizzati con fogli di alluminio.
Questo sistema d’interazione, progettato utilizzando la scheda Arduino Uno, è dotato di sei potenziometri rotativi e di undici sensori capacitivi. Cap-Pad può essere utilizzato come controller seriale per Pure Data, Max/MSP, Processing e qualsiasi altro programma e ambiente capace di ricevere messaggi inviati da Arduino attraverso una connessione seriale. I sensori capacitivi possono essere utilizzati come pulsanti per rilevare la presenza ovvero l’assenza del tocco di una persona. É anche possibile utilizzare i fogli di alluminio di Cap-Pad come sensori di prossimità a breve distanza. In questo caso i sensori forniscono un segnale che varia in maniera proporzionale alla variazione della distanza tra sensore e corpo umano.
Il video seguente mostra CapPad in azione.
Arduino sensori capacitivi
Riferimenti utili
Per informazioni e dettagli su come costruire e programmare i sensori capacitivi con Arduino è utile fare riferimento all’articolo dedicato alla Capacitive Sensing Library disponibile all’interno del sito ufficiale di Arduino. Esiste in rete un’ampia serie di guide ed esempi su come realizzare e utilizzare questo tipo di sensore. È, quindi, superfluo in questa sede dilungarsi a presentare i suoi dettagli di funzionamento. Sembra, invece, utile illustrare le scelte progettuali e i vincoli che ne sono derivati. Per esempio, la scelta di realizzare un numero di sensori capacitivi quanto mai insolito come undici.
Come funziona
L’immagine (Immagine scaricata dalla pagina del sito di Arduino dedicata alla Capacitive Sensing Library ) mostra lo schema elettrico e il meccanismo di funzionamento del sensore capacitivo. Una resistenza di valore medio-alto (per Cap-Pad sono state utilizzate resistenze da 2.2MΩ) viene inserita tra due porte digitali di Arduino. Una porta viene utilizzata come emettitore e l’altra come ricevitore. L’emettitore può essere utilizzato in comune tra più sensori capacitivi per questo motivo utilizzando Arduino Uno che è dotato di dodici porte digitali (escludendo le porte 0 e 1 usate come RX e TX per la comunicazione seriale) restano libere undici porte digitali a cui possono essere connessi i terminali ricevitori di altrettanti sensori capacitivi.
Qualsiasi materiale conduttivo collegato al terminale ricevitore della resistenza crea un accoppiamento resistivo capacitivo caratterizzato da una costante di tempo. La costante di tempo è pari al prodotto tra resistenza e capacità e, in questo caso, dipende esclusivamente dalla variazione della capacità visto che il valore di resistenza resta costante. La stima della capacità viene realizzata dalle funzioni interne alla libreria inviando un segnale impulsivo sull’emettitore (una transizione tra stato basso e stato alto) e avviando un ciclo all’interno del quale viene incrementato, per ogni iterazione, il valore di una variabile intera. Quando l’impulso, dopo un certo intervallo di tempo che dipende dalla costante di tempo RC del sensore, viene rilevato sulla porta ricevitore il ciclo viene bloccato e il valore raggiunto dalla variabile costituisce una stima della capacità espressa in una unità di misura arbitraria.
Architettura di Cap-Pad
Sensore capacivito
L’immagine mostra lo schema elettrico usato per la connessione degli undici sensori capacitivi. La porta numero 2 è stata utilizzata come emettitore comune a tutti i sensori capacitivi e collegata a uno dei piedini delle resistenze da R1 a R11. Gli altri piedini delle undici resistenze usati come ricevitori sono stati collegati rispettivamente alle porte di Arduino dalla 3 alla 13 e al corrispondente foglio di alluminio che realizza il sensore capacitivo (nell’immagine rappresentato attraverso il simbolo dell’antenna e indicato con le sigle CapSens-1,…CapSens-11).
Per Cap-Pad sono state utilizzate resistenze da 2.2MΩ, sperimentazioni successive hanno mostrato che è meglio utilizzare valori di resistenza più alti come 10 o 20MΩ per migliorare la stabilità dei valori misurati e soprattutto per rendere più preciso l’utilizzo dei fogli di alluminio come sensori di prossimità piuttosto che come semplici pulsanti.
La fotografia mostra un dettaglio della scheda realizzata per la connessione dei sensori capacitivi; in particolare sono visibili le undici resistenze da 2.2MΩ (codice colore rosso-rosso-verde) con un piedino in comune collegato alla porta digitale 2 di Arduino e gli altri piedini alle restanti porte digitali e ai sensori capacitivi.
Potenziometri
L’immagine mostra lo schema di connessione utilizzato per collegare i sei potenziometri alle porte analogiche di Arduino. I piedini esterni di ogni potenziometro sono collegati uno alla porta 5V di Arduino (connessioni in rosso nell’immagine) e l’altro a GND (connessioni di colore nero). Il piedino centrale di ogni potenziometro viene collegato alla corrispondente porta analogica da A0 ad A5 (connessione in arancio per il potenziometro R1,…, in blu per R6). In questo modo su ogni ingresso analogico si potrà leggere un valore di tensione compreso tra 0 e 5V a seconda della posizione di ciascun potenziometro.
Un semplice protocollo di comunicazione seriale è stato sviluppato per realizzare la trasmissione dei dati tra Arduino e Pure Data. I dettagli del codice Arduino e la patch di Pure Data sviluppati appositamente per realizzare l’invio dello stato dei sensori capacitivi e dei potenziometri di Cap-pad sono stati presentati nella guida: Un protocollo di comunicazione Pure Data Arduino.
Per una semplice introduzione a come realizzare una trasmissione di dati da Arduino a Pure Data è possibile fare riferimento anche a questa altra guida: Inviare numeri interi a 8bit da arduino a pure data.
Qui di seguito il codice utilizzato per programmare Arduino:
/*++ Arduino code for Cap-Pad ++
DESCRIPTION:
Cap-Pad (shortening of Capacitive Pad) is a prototype based on the
use of capacitive sensors made from aluminium foil.
Cap-Pad uses an Arduino Uno and it provides six rotary potentiometers
and eleven touch sensors. Cap-Pad can be used as a serial controller
for Pure Data, Max / MSP, Processing and any other program and
environment able to receive the serial messages sent from the
Arduino board.
CIRCUIT:
For more information about Cap-Pad follow this link:
Arduino capacitive sensor: Cap-Pad
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Copyright © 2016 Costantino Rizzuti
Artis Lab © 2016
www.artislab.it
info@artislab.it
*/
#include <CapacitiveSensor.h>
CapacitiveSensor cs23 = CapacitiveSensor(2,3);
CapacitiveSensor cs24 = CapacitiveSensor(2,4);
CapacitiveSensor cs25 = CapacitiveSensor(2,5);
CapacitiveSensor cs26 = CapacitiveSensor(2,6);
CapacitiveSensor cs27 = CapacitiveSensor(2,7);
CapacitiveSensor cs28 = CapacitiveSensor(2,8);
CapacitiveSensor cs29 = CapacitiveSensor(2,9);
CapacitiveSensor cs210 = CapacitiveSensor(2,10);
CapacitiveSensor cs211 = CapacitiveSensor(2,11);
CapacitiveSensor cs212 = CapacitiveSensor(2,12);
CapacitiveSensor cs213 = CapacitiveSensor(2,13);
boolean isTriggered1=false;
boolean isTriggered2=false;
boolean isTriggered3=false;
boolean isTriggered4=false;
boolean isTriggered5=false;
boolean isTriggered6=false;
boolean isTriggered7=false;
boolean isTriggered8=false;
boolean isTriggered9=false;
boolean isTriggered10=false;
boolean isTriggered11=false;
int Soglia=180;
int Samples=15;
int i = 0;
int lastValue0=0;
int lastValue1=0;
int lastValue2=0;
int lastValue3=0;
int lastValue4=0;
int lastValue5=0;
void setup(){
//cs23.set_CS_AutocaL_Millis(0xFFFFFFFF);
Serial.begin(115200);
}
void loop(){
int PotValue0=analogRead(A0);
if(abs(PotValue0-lastValue0)>1)
{
// print out the value you read:
int MapPotValue0 = map(PotValue0, 0, 1023, 0, 199);
Serial.write(MapPotValue0);
Serial.write(200);
lastValue0=PotValue0;
}
int PotValue1=analogRead(A1);
if(abs(PotValue1-lastValue1)>1)
{
// print out the value you read:
int MapPotValue1 = map(PotValue1, 0, 1023, 0, 199);
Serial.write(MapPotValue1);
Serial.write(201);
lastValue1=PotValue1;
}
int PotValue2=analogRead(A2);
if(abs(PotValue2-lastValue2)>1)
{
// print out the value you read:
int MapPotValue2 = map(PotValue2, 0, 1023, 0, 199);
Serial.write(MapPotValue2);
Serial.write(202);
lastValue2=PotValue2;
}
int PotValue3=analogRead(A3);
if(abs(PotValue3-lastValue3)>1)
{
// print out the value you read:
int MapPotValue3 = map(PotValue3, 0, 1023, 0, 199);
Serial.write(MapPotValue3);
Serial.write(203);
lastValue3=PotValue3;
}
int PotValue4=analogRead(A4);
if(abs(PotValue4-lastValue4)>1)
{
// print out the value you read:
int MapPotValue4 = map(PotValue4, 0, 1023, 0, 199);
Serial.write(MapPotValue4);
Serial.write(204);
lastValue4=PotValue4;
}
int PotValue5=analogRead(A5);
if(abs(PotValue5-lastValue5)>1)
{
// print out the value you read:
int MapPotValue5 = map(PotValue5, 0, 1023, 0, 199);
Serial.write(MapPotValue5);
Serial.write(205);
lastValue5=PotValue5;
}
long total1=cs23.capacitiveSensor(Samples);
if(total1>Soglia)
{
if(!isTriggered1)
{
Serial.write(1);
Serial.write(206);
isTriggered1=true;
}
} else
{
if(isTriggered1)
{
isTriggered1=false;
Serial.write(0);
Serial.write(206);
}
}
long total2=cs24.capacitiveSensor(Samples);
if(total2>Soglia)
{
if(!isTriggered2)
{
Serial.write(1);
Serial.write(207);
isTriggered2=true;
}
} else
{
if(isTriggered2)
{
isTriggered2=false;
Serial.write(0);
Serial.write(207);
}
}
long total3=cs25.capacitiveSensor(Samples);
if(total3>Soglia)
{
if(!isTriggered3)
{
Serial.write(1);
Serial.write(208);
isTriggered3=true;
}
} else
{
if(isTriggered3)
{
isTriggered3=false;
Serial.write(0);
Serial.write(208);
}
}
long total4=cs26.capacitiveSensor(Samples);
if(total4>Soglia)
{
if(!isTriggered4)
{
Serial.write(1);
Serial.write(209);
isTriggered4=true;
}
} else
{
if(isTriggered4)
{
isTriggered4=false;
Serial.write(0);
Serial.write(209);
}
}
long total5=cs27.capacitiveSensor(Samples);
if(total5>Soglia)
{
if(!isTriggered5)
{
Serial.write(1);
Serial.write(210);
isTriggered5=true;
}
} else
{
if(isTriggered5)
{
isTriggered5=false;
Serial.write(0);
Serial.write(210);
}
}
long total6=cs28.capacitiveSensor(Samples);
if(total6>Soglia)
{
if(!isTriggered6)
{
Serial.write(1);
Serial.write(211);
isTriggered6=true;
}
} else
{
if(isTriggered6)
{
isTriggered6=false;
Serial.write(0);
Serial.write(211);
}
}
long total7=cs29.capacitiveSensor(Samples);
if(total7>Soglia)
{
if(!isTriggered7)
{
Serial.write(1);
Serial.write(212);
isTriggered7=true;
}
} else
{
if(isTriggered7)
{
isTriggered7=false;
Serial.write(0);
Serial.write(212);
}
}
long total8=cs210.capacitiveSensor(Samples);
if(total8>Soglia)
{
if(!isTriggered8)
{
Serial.write(1);
Serial.write(213);
isTriggered8=true;
}
} else
{
if(isTriggered8)
{
isTriggered8=false;
Serial.write(0);
Serial.write(213);
}
}
long total9=cs211.capacitiveSensor(Samples);
if(total9>Soglia)
{
if(!isTriggered9)
{
Serial.write(1);
Serial.write(214);
isTriggered9=true;
}
} else
{
if(isTriggered9)
{
isTriggered9=false;
Serial.write(0);
Serial.write(214);
}
}
long total10=cs212.capacitiveSensor(Samples);
if(total10>Soglia)
{
if(!isTriggered10)
{
Serial.write(1);
Serial.write(215);
isTriggered10=true;
}
} else
{
if(isTriggered10)
{
isTriggered10=false;
Serial.write(0);
Serial.write(215);
}
}
long total11=cs213.capacitiveSensor(Samples);
if(total11>Soglia)
{
if(!isTriggered11)
{
Serial.write(1);
Serial.write(216);
isTriggered11=true;
}
} else
{
if(isTriggered11)
{
isTriggered11=false;
Serial.write(0);
Serial.write(216);
}
}
//delayMicroseconds(1);
}
Perché non dai anche uno sguardo ai nostri prodotti?
[ecwid widgets=”productbrowser” categories_per_row=”3″ grid=”1,2″ list=”60″ table=”60″ default_category_id=”0″ default_product_id=”0″ category_view=”grid” search_view=”list” minicart_layout=”MiniAttachToProductBrowser”]
Se ti piace questo progetto e vuoi provare a realizzarlo per problemi, curiosità oppure suggerimenti scrivici qui di seguito: