Circuito Arduino e codice finale per un dispositivo hi-Storia
Durante questa lezione completerai il codice per permettere al circuito capacitivo da te assemblato di dialogare con l’applicazione hi-Storia play installata su desktop. Implementerai le funzioni per rendere più efficace il circuito sin qui realizzato, soprattutto in relazione al tipo d’uso previsto con il dispositivo tattile interattivo.
A titolo esplicativo, verrà visualizzato un circuito con 5 sensori, ma ovviamente tieni presente che il tuo circuito può avere più o meno attivatori.
In primo luogo, sviluppa una funzionalità extra per gestire il momento in cui si toccano due sensori contemporaneamente e per impedire che partano ulteriori segnali (inutili) riguardanti il sensore che è attualmente attivo.
Lavorando sulla versione iterativa del codice, introduci tre variabili di controllo, che chiamerai traccia, tracciattiva e doppiotocco.
Dichiara traccia e tracciattiva insieme alle altre variabili e costanti. La variabile traccia viene utilizzata per memorizzare l’ultimo ID inviato, quindi l’ID attualmente attivo.
#include <CapacitiveSensor.h>
const int commonpin = 13;
const int numbersensors = 3;
CapacitiveSensor* capSensor[numbersensors];
int traccia=0;
int tracciattiva=-1;
int threshold = 500;
La variabile traccia indica il sensore attualmente toccato, tracciattiva memorizza il precedente sensore toccato.
Va quindi fatta qualche piccola modifica nel loop per implementare questi controlli. Nei commenti la spiegazione del codice.
void loop() {
long sensorValue;
// variabile per capire se abbiamo toccato due sensori. lo imposto a 0, cioe' nessun tocco
int tocco= 0;
// dichiaro la variabile i fuori dal for cosi' la riusera' nel print finale
int i;
for(i=0;i < numbersensors;i++){ // catturo i valori di output di ogni sensore capacitivo sensorValue = capSensor[i]->capacitiveSensor(30);
//per verificare il funzionamento di tutti i sensori, de-commenta la riga successiva
//Serial.println(sensorValue);
if(sensorValue > threshold){
//tocco diventa 1.
// se rimane 1, vuol dire che dentro il ciclo for abbiamo toccato un solo sensore.
// se aumenta, vuol dire che piu' di un sensore ha passato la soglia
tocco++;
traccia=i;
}
}
// fine del ciclo for per la cattura dei valori di output
// alla fine del ciclo analizzo i tocchi
//se ho toccato almeno 1 sensore
if(tocco>0) {
//se ho toccato 1 ed un solo sensore
if(tocco==1){
// invio l'ID del sensore attivato solo se in precedenza avevo toccato un altro sensore
if(traccia!=tracciattiva){
Serial.println(traccia+1);
tracciattiva=traccia;
}
}else{
//invio il carattere 90 che l'app player interpreta come segnale del tocco contemporaneo due sensori
Serial.println(90);
}
}
delay(50);
}
Così facendo, se si tocca un sensore viene stampato in Seriale un solo ID anziché una lunga sequenza, come nei precedenti script.
Inoltre, se si toccano 2 sensori viene stampato il carattere 90.
Puoi scaricare questo codice completo in formato .ino per IDE Arduino o Eclipse.
Handshake
Per concludere lo script finale mancano due operazioni finali: implementare un semplice algoritmo di l’handshake e correggere i println.
L’handshake in informatica è il momento in cui due dispositivi stabiliscono regole comuni di comunicazione. Nel caso di hi-Storia, l’handshake è una funzione basilare che permette solamente di identificare il dispositivo hi-Storia e attivare il collegamento tra l’applicazione per PC e il dispositivo connesso via USB.
Senza un identificatore, l’applicazione potrebbe connettersi a qualsiasi dispositivo via USB e rimanere in attesa di segnali.
Nel codice hi-Storia l’handshake è mantenuto semplice ed è così strutturato:
- Arduino rimane in stato “dormiente”, non svolgendo alcuna operazione se non inviare in Seriale dei caratteri Z e rimanere in ascolto, sempre via Seriale, attendendo un carattere H di sveglia.
- Quando l’applicazione PC hi-Storia play si avvia, invia il carattere H a tutti i dispositivi connessi via Seriale (USB, bluetooth).
- Arduino riceve il carattere H, si sveglia, accende i sensori capacitivi e reinvia un carattere H.
- L’applicazione PC hi-Storia player riceve il carattere H e carica la schermata iniziale.
Dichiara due nuove variabili in testa al codice: handshake, una booleana che indica se l’handshake è stato eseguito o meno, ed inputval, un tipo char che memorizza i caratteri provenienti da Seriale, in pratica i segnali dall’applicazione PC.
Introduci anche una nuova costante, const String idaudio, che è l’identificatore unico del dispositivo e permette all’applicazione di capire che dispositivo è connesso al PC e quali contenuti rendere disponibili (se è collegata l’audioguida del Duomo di Milano l’applicazione aprirà i contenuti relativi al duomo, se è collegata alla Basilica di San Pietro l’applicazione aprirà i contenuti relativi alla basilica, e così via)
#include <CapacitiveSensor.h>
const int commonpin = 13;
const int numbersensors = 3;
const String idaudio = "SBR012015A";
CapacitiveSensor* capSensor[numbersensors];
int traccia=0;
int tracciattiva=-1;
boolean handshake=false;
char inputval;
int threshold = 500;
La funzione start rimarrà ancora identica, mentre il loop viene introdotto da un condizionale: se l’handshake non è stato effettuato, invia caratteri Z e rimani in attesa dell’H. Se arriva l’H, attiva il resto del codice e quindi i sensori capacitivi.
void loop() {
// HANDSHAKE
//se NON abbiamo stabilito una connessione con l'app PC (o smarthphone)
if(!handshake){
// inviamo al PC o allo smarthphone un segnale contente il carattere "Z".
// diciamo: il dispositivo è connesso, ma è dormiente!
Serial.println('Z');
// se è stabilita una connessione
if (Serial.available()) {
// salviamo su una variabile il messaggio che ci arriva dal PC (o smartphone)
inputval = Serial.read();
// se riceviamo il carattere "H", vuol dire che il PC ci ha riconosciuto: sveglia!
if (inputval == 'H') {
//il dispositivo diventa operativo
handshake=true;
}
delay(10);
}
delay(500);
}else{
/** codice del sensore capacitivo **/
}
In fondo alla parte di codice del sensore capacitivo, crea anche due condizioni: se via Seriale arriva il carattere #, restituiamo la stringa identificatrice del dispositivo (idaudio), se arriva il carattere #fai tornare il dispositivo in stato dormiente (handshake = false).
Ecco il codice completo dello script con l’handshake:
#include
// indichiamo il PIN utilizzato come trasmettitore per tutti i sensori capacitivi
const int commonpin = 13;
// indichiamo il numero di sensori capacitivi inseriti.
//Cambia questo valore in base alle tue esigenze
const int numbersensors = 3;
// Attenzione, questo valore è specifico per ogni dispositivo!
// Accordarsi con il team di hi-Storia così da ricevere il tuo ID
// e mettere il rete il tuo dispositivo con gli altri dispositivi creati in Italia
const String idaudio = "SBR012015A";
CapacitiveSensor* capSensor[numbersensors];
int traccia=0;
int tracciattiva=-1;
boolean handshake=false;
char inputval;
int threshold = 500;
void setup() {
Serial.begin(9600);
//inizializzazione dei sensori capacitivi
int i = 0;
// creo un ciclo, eseguendolo un numero di volte pari al numero di sensori
while(i < numbersensors){
// questo controllo lo eseguo perche' possiamo utilizzare anche PIN superiori al 13
// con questo controllo superiamo il 13, andiamo al 14 e non incrementando la variabile i
// cosi' da eseguire il controllo per il numero di sensori indicati in numbersensors
if(i!=commonpin){
// nella versione con bluetooth, PIN0 e PIN1 sono utilizzati per la trasmissione dati
//quindi li lasciamo liberi, partendo dal PIN2 (0+2 nella prima iterazione del ciclo while)
capSensor[i] = new CapacitiveSensor(commonpin,i+2);
i++;
}
}
}
void loop() {
// HANDSHAKE
//se NON abbiamo stabilito una connessione con l'app PC (o smarthphone)
if(!handshake){
// inviamo al PC o allo smarthphone un segnale contente il carattere "Z".
// diciamo: il dispositivo è connesso, ma è dormiente!
Serial.println('Z');
// se è stabilita una connessione
if (Serial.available()) {
// salviamo su una variabile il messaggio che ci arriva dal PC (o smartphone)
inputval = Serial.read();
// se riceviamo il carattere "H", vuol dire che il PC ci ha riconosciuto: sveglia!
if (inputval == 'H') {
//il dispositivo diventa operativo
handshake=true;
}
delay(10);
}
delay(500);
}else{
//se il dispositivo è collegato ed abbiamo stabilito una connessione con l'app PC (o smarthphone)
//CAPACITIVE
long sensorValue;
// variabile per capire se abbiamo toccato due sensori. lo imposto a 0, cioe' nessun tocco
int tocco= 0;
// dichiaro la variabile i fuori dal for cosi' la riusera' nel print finale
int i;
for(i=0;i < numbersensors;i++){ // catturo i valori di output di ogni sensore capacitivo sensorValue = capSensor[i]->capacitiveSensor(30);
//per verificare il funzionamento di tutti i sensori, de-commenta la riga successiva
//Serial.println(sensorValue);
if(sensorValue > threshold){
//tocco diventa 1.
// se rimane 1, vuol dire che dentro il ciclo for abbiamo toccato un solo sensore.
// se aumenta, vuol dire che piu' di un sensore ha passato la soglia
tocco++;
traccia=i;
}
}
// fine del ciclo for per la cattura dei valori di output
// alla fine del ciclo analizzo i tocchi
//se ho toccato almeno 1 sensore
if(tocco>0) {
//se ho toccato 1 ed un solo sensore
if(tocco==1){
// invio l'ID del sensore attivato solo se in precedenza avevo toccato un altro sensore
if(traccia!=tracciattiva){
Serial.println(traccia+1);
tracciattiva=traccia;
}
}else{
//invio il carattere 90 che l'app player interpreta come segnale del tocco contemporaneo due sensori
Serial.println(90);
}
}
//ultima verifica: vediamo se riceviamo altri segnali dall'app PC (o smartphone)
if (Serial.available()) {
inputval = Serial.read();
// se arriva il segnale con il carattere chiocciola
if (inputval == '@') {
// vuol dire che dobbiamo resettare il dispositivo
handshake=false;
}
// se arriva il segnale con il carattere cancelletto
if (inputval == '#') {
// restituisco l'ID del dispositivo
Serial.println(idaudio);
}
}
delay(50);
}
}
Puoi scaricare questo codice completo in formato .ino per IDE Arduino o Eclipse.
Il monitor seriale dell’Arduino IDE permette anche l’invio di caratteri ad Arduino, per cui puoi sperimentare il comportamento dell’handshake. Quando avvierai Arduino con questo nuovo script, riceverai solamente una serie di Z, un carattere ogni mezzo secondo (500ms). Toccando i sensori capacitivi non accadrà nulla. Se digiterai il carattere H (presta attenzione al maiuscolo) e premendo invio, Arduino terminerà di inviare i caratteri Z e avvierà tutte le funzioni del circuito capacitivo.
Da Serial.println a Serial.write
L’ultimo passaggio prima dell’upload finale consiste nel modificare tutti i metodi println in write, perché il circuito capacitivo comunicherà con l’applicazione PC attraverso i byte anziché i caratteri. Fino ad ora è stato mantenuto il println perché leggibile attraverso il monitor seriale. Quindi, una volta modificato in write, l’output di Arduino non sarà più intellegibile via monitor ma potrà comunicare con l’applicazione hi-Storia play.
Puoi scaricare questo codice finale in formato .ino per IDE Arduino o Eclipse.
Buon lavoro con prossime fasi dell’Hi-Storia labs!