Riconoscitore di colori per non vedenti e daltonici [fai-da-te]

Blind

Tutte le persone “sane” spesso sottovalutano quanto potrebbe essere importante e bello, per chi viceversa sano non lo è, riuscire ad avere una percezione del mondo più completa e, in qualche modo, compensare le sue difficoltà e debolezze. Quest’oggi vi presentiamo un’idea. Un concept. Un progetto nato da un’idea quasi estemporanea: un riconoscitore di colori per non vedenti e daltonici. Questo particolare sistema, molto semplice, permetterà loro di conoscere il colore di un oggetto semplicemente avvicinandovi il dispositivo. Questa prima versione è poco più che dimostrativa ma ha lo scopo di semplificare e schematizzare un problema apparentemente molto complesso per poi, nel futuro, venire sviluppata e funzionare all’altezza delle più esigenti aspettative. Siete pronti a scoprire di che si tratta?

Quello che vi presentiamo oggi, come annunciato nell’introduzione all’articolo, è un esperimento. Si tratta di un esperimento molto semplice ma che apre la strada ad un possibile grande sviluppo futuro. È una scelta consapevole quella che facciamo oggi, di presentarvi un progetto nella sua veste più elementare. Col tempo, e nei commenti, avremo modo di accogliere ogni genere di suggerimento dopo avervi proposto quali sono le nostre idee per migliorare la realizzazione di questo progetto in maniera tale da ottenere un sistema, in definitiva, migliore. Ecco a voi la prima versione del riconoscitore di colori.

L’idea: di che cosa stiamo parlando?

Come abbiamo detto in apertura, lo scopo di un riconoscitore di colori per non vedenti è quello di segnalare alla persona che non può vedere il colore, per esempio grazie all’impiego di segnalazione acustica. In questa prima versione, come vedremo, la segnalazione acustica implementata non è altro che una semplice sequenza di impulsi sonori che, una volta addestrati a riconoscere, sarà facile utilizzare. Vediamo, quindi, adesso di che cosa si tratta mettendoci fisicamente le mani sopra.

Fase 1: caratteristiche del sistema

L’idea di base è molto semplice: acquisire il colore e associare a questo un segnale acustico riconoscibile. Il segnale può essere un segnale acustico semplice, come quello che vedremo, oppure qualcosa di più complesso, per esempio una registrazione della voce di qualcuno che pronuncia il colore.
Con l’idea di mantenere il tutto molto semplice ed immediato, per questa prima versione abbiamo scelto dei semplici avvisatori acustici, riprodotti tramite un altoparlante del quale parleremo a breve.
L’idea di base è che il sistema dovesse essere Open Source (e su questa, ovviamente, non abbiamo mai avuto dubbi) e per questo abbiamo cercato di realizzare un sistema dal costo estremamente contenuto, oltre che molto rudimentale.
Più avanti troverete lo schema elettrico ed il codice che potrete eseguire voi stessi.
Arduino anima questa prima versione per via della sua immediatezza e della facilità con la quale è possibile programmarlo.

Fase 2: cosa serve

Ovviamente, per realizzare questo progetto, come tutti gli altri, è necessario curare due aspetti della questione, ovvero il lato hardware ed il lato software. Ma andiamo con ordine e vediamo il primo dei due. È giunto, quindi, il momento di fare la nostra “lista della spesa”. Per realizzare il progetto quindi ci servono:

  • Arduino (ovviamente!);
  • 1 LED rosso;
  • 1 LED verde;
  • 1 LED blu;
  • 1 LED RGB;
  • 3 resistenze da 220 Ohm;
  • 3 resistenze da 1kOhm;
  • un altoparlante da 0,5 W
  • un cospicuo numero di fili (tanto servono sempre!).

NB: questa versione progetto è stato realizzato con Arduino UNO rev. 3 ma, ovviamente, è possibile utilizzare qualunque altra scheda. Tuttavia, il consiglio rimane quello di “accontentarsi” di questa per provare a rifare questo stesso semplice esperimento. Ovviamente, man mano che il progetto verrà perfezionato e si complicherà, sarà sempre meno possibile realizzarlo su questa scheda e allora potrete considerare seriamente di cambiare la scheda.

Vedremo più avanti che questa stessa prima realizzazione può essere migliorata dotando l’altoparlante di un amplificatore operazionale dedicato.

Per quanto riguarda il lato software, invece, c’è la necessità di utilizzare, prima di noi, un software che sia in grado di creare schemi circuitali perché senza lo schematico, evidentemente, non si può andare avanti. Per rispondere a questa esigenza, sottolineando sempre la natura prettamente hobbystica di questa incarnazione del progetto, si può utilizzare Fritzing.

Gli amanti di Arduino sanno già di che cosa si tratta mentre per tutti coloro che ancora non dovessero saperlo, si tratta di uno dei software che “accompagna” la scheda e permette di fare prototipi rapidi supportando l’inesperto progettista nella fase di prototipazione (realizzata su una breadborad virtuale) fino allo schematico.

Dopo di che, evidentemente sarà necessario programmare Arduino e per questo è possibile procurarsi la GUI direttamente dal sito. La resa attuale, ancorché in esso la versione beta ma perfettamente funzionante, è la 1.5.2.

A questo punto della spiegazione vale la pena di sottolineare che una delle prime modifiche che si può fare al progetto è quella di trasformare i semplici segnali acustici che vedremo produrre all’altoparlante in messaggi vocali.
Una delle possibilità è proprio convertire l’audio registrato da un comune registratore, anche per esempio utilizzando il microfono del computer, convertendolo in *.wav per poi farlo diventare in un formato composto da comode stringhe.
In pratica si potrebbe, in un momento successivo ipotizzando una miglioria del progetto, utilizzare la libreria disponibile sul Playgournd di Arduino.

Fase 3: creazione dello schema circuitale

Per realizzare lo schema circuitale, come abbiamo già detto, abbiamo deciso di utilizzare Fritzing. La comodità di questo programma, per il neo-smanettone, è invidiabile. Semplifica molte dinamiche della creazione di un progetto e permette di visualizzare immediatamente quello che poi il progettista dovrà fare materialmente per creare il prototipo e dare vita al suo progetto. Grazie a questo programma è stato realizzato lo schema riportato qui di seguito

Ed ora, riportiamo un’immagine intermedia del prototipo quasi completo.

Qui di seguito due immagini del circuito in funzione, il primo mentre riconosce il colore verde

il secondo mentre riconosce il blu

A questo punto, il circuito era ancora in una fase di realizzazione intermedia e mancava ancora il LED RGB.

NB: nella versione utilizzata, la libreria di Fritzing non prevedeva i phototransistor. Per questo motivo, nello schema circuitale, sono state inserite delle “semplici” fotoresistenze.

Fase 4: assemblaggio e programmazione

Dopo aver realizzato su breadboard il circuito, come riportato nelle immagini di cui sopra, si è proceduto alla programmazione di Arduino utilizzando il codice riportato qui di seguito.

/* Riconoscitore di colori */

// Sezione di acquisizione colore!
int red = 13; // LED Rosso su pin 13 (digitale)
int green = 12;
int blu = 11;
int ired = 0; // fototransistor dedicato al rosso su pin A0
int igreen = 1;
int iblu = 2;
int val_red = 0; // valore letto x il rosso
int val_green = 0;
int val_blu = 0;

int speakerPin = 10;

In questa prima sezione del codice sono state individuate due “porzioni”, la prima per l’acquisizione e gestione del colore, la seconda per quanto riguarda l’audio. Vengono, pertanto, indicati nel codice tutti i pin utilizzati per configurare il sistema. Successivamente, come tutti sappiamo, lo sketch di Arduino deve essere composto di due funzioni fondamentali, ovvero setup() e loop(). Nel primo, viene assegnata la funzione specifica di ciascun pin. Viene, inoltre, inizializzata la comunicazione tramite la porta seriale che, come vedrete, viene qui utilizzata a solo fine di debug durante l’esecuzione del codice.

void setup()
{
  Serial.begin(9600);
  pinMode(ired, INPUT);
  pinMode(igreen, INPUT);
  pinMode(iblu, INPUT);
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blu, OUTPUT);
  pinMode(speakerPin, OUTPUT);
}

Ed ora, mediante la funzione loop(), inizia la vera e propria esecuzione del programma.

Come dicevamo, il funzionamento è molto semplice ma prima di andare avanti, un piccolo test.

In questo caso: disponiamo di 3 LED di colori distinti (e noti a priori). Viene acceso un LED per volta ed i fototransistor, fisicamente e circuitalmente separati dai diodi, sono deputati a rilevare la presenza del colore perchè una volta accesi, i LED indurranno una fotocorrente! Semplice no?

Rileverò allora che quel colore è presente grazie alla misura della corrente. Il programma, infatti, non appena legge la corrente, semplicemente maggiore di 0 (caso non ideale vista la possibilità di rumore), oppure comunque superiore ad una data soglia, comanda l’esecuzione dell’audio relativo (così come stabilito).

Questo stesso processo viene realizzato per ciascun colore.
Per fare questo, adesso, è necessario decidere che il segnale di riconoscimento nel caso di colore rosso sarà un “beep” singolo di una data tonalità mentre nel caso in cui sia presente il colore verde si sentiranno due “beep” di tonalità leggermente più alta. Quando, invece, si rileverà il colore blu, i “beep” emessi saranno tre e di tonalità ancora più alta. Per fare tutto questo inizializzo un contatore d’appoggio, i.

void loop()
{
  digitalWrite(red, HIGH);
  delay(100);
  val_red=analogRead(ired);
  if(val_red) {
    Serial.println(val_red);
    analogWrite(speakerPin, 128);
    delay(100);
    analogWrite(speakerPin, 0);
  };
  digitalWrite(red, LOW);
  delay(1000);
  val_red=analogRead(ired);
  Serial.println(val_red);
 
  digitalWrite(green, HIGH);
  delay(500);
  val_green=analogRead(igreen);
  if(val_green >= 0) {
    Serial.println(val_green);
    for (i==0;i<2;i++){
      analogWrite(speakerPin, 200);
      delay(100);
      analogWrite(speakerPin, 0);
      delay(100);
    }
  };
  digitalWrite(green, LOW);
  delay(1000);
  val_green=analogRead(igreen);
  Serial.println(val_green);
 
  digitalWrite(blu, HIGH);
  delay(500);
  i=0;
  val_blu=analogRead(iblu);
  if(val_blu) {
    Serial.println(val_blu);
    for (i==0;i<3;i++){
      analogWrite(speakerPin, 240);
      delay(100);
      analogWrite(speakerPin, 0);
      delay(100);
    }
  };
  digitalWrite(blu, LOW);
  delay(5000);
  val_blu=analogRead(iblu);
  Serial.println(val_blu);
}

 

A questo punto, è il momento di entrare nel vivo del programma.
Quello che dobbiamo fare è cercare di riconoscere degli oggetti con colore specificato in maniera tale da comunicare l’informazione.
Pertanto scriveremo, sempre all’interno del loop(), il seguente codice:

void loop()
{
  int i=0;
  digitalWrite(red, HIGH);
  digitalWrite(green, HIGH);
  digitalWrite(blu, HIGH);
  delay(100);
  val_red=analogRead(ired);
  val_green=analogRead(igreen);
  val_blu=analogRead(iblu);

  if(val_red < val_green && val_red < val_blu && val_green <= val_blu) {
    Serial.println(val_red);
    analogWrite(speakerPin, 128);
    delay(100);
    analogWrite(speakerPin, 0);
    val_red=analogRead(ired);
    Serial.println(val_red);
  }
  else if (val_green < val_red && val_green < val_blu && val_red <= val_blu) {
    Serial.println(val_green);
    i=0;
    for (i==0;i<2;i++){
      analogWrite(speakerPin, 200);
      delay(100);
      analogWrite(speakerPin, 0);
      delay(100);
    }
    val_green=analogRead(igreen);
    Serial.println(val_green);
  }
  else if (val_blu < val_red && val_blu < val_green && val_green <= val_red) {
    Serial.println(val_blu);
    i=0;
    for (i==0;i<3;i++){
      analogWrite(speakerPin, 240);
      delay(100);
      analogWrite(speakerPin, 0);
      delay(100);
    }
    val_blu=analogRead(iblu);
    Serial.println(val_blu);
  }
  delay(1000);
}

La routine funziona in maniera molto elementare: il principio base, cioè il motivo, per cui un oggetto “è di” un determinato colore è dato dal fatto che viene colpito dalla luce, nello spettro del visibile, ma emette sole soltanto le radiazioni che non sono sue proprie. Mi aspetto, pertanto, che non appena l’oggetto venga illuminato da una radiazione che contenga il suo colore, tutto ciò che viene riflesso sia quella radiazione meno la frequenza (più verosimilmente le frequenze) caratteristica del colore in particolare.

Seguendo questo elementare ragionamento, abbiamo creato una struttura tipo box di cartoncino nero (ovviamente perché è un colore neutro) che isolasse i LED assieme con il rispettivo fotodiodo. Per valutare quale colore, tra i tre che stiamo analizzando, fosse quello caratteristico dell’oggetto, abbiamo illuminato quest’ultimo accendendo contemporaneamente i LED.

Nello script vengono valutate e lette le componenti di colore, intese come fotocorrente proveniente da ciascuno dei tre, confrontate tra loro e poi viene deciso quale colore è prevalente rispetto agli altri.
La condizione, in realtà anche questa piuttosto semplice: la fotocorrente associata al fotodiodo vicino alla LED rosso viene confrontata con le altre due. Se questa risulta minore sia della fotocorrente associata al verde sia di quella associata al blu e nel contempo le componenti verde e blu sono simili tra loro, allora il rosso è il colore prevalente (perché non è stato riflesso!).

Una volta che questo è stato riconosciuto, viene prodotto l’audio codificato relativo. Anche per questo caso sono stati utilizzati quei segnali audio di cui abbiamo parlato in precedenza. Ovviamente questi sono liberi e modificabili ma l’importante è che siano, fintanto che non viene implementata qualche segnalazione più immediatamente riconoscibile, facilmente identificabili.

Come elementi di test per verificare la bontà della funzionalità del codice abbiamo utilizzato delle scatole per attrezzi, tipo quelle in foto:

sono scatole classiche, monocromatiche, di colore abbastanza riconoscibile e pertanto degli ottimi campioni.
Per fare la prova di riconoscimento sul verde è stato anche utilizzato il retro di una scheda, come mostra la figura che segue

Vale la pena di far notare, a questo punto, che all’interno delle singole condizioni dei colori che prevedono l’utilizzo della variabile di appoggio i, è stato necessario un piccolo trucco: riassegnare la variabile, onde evitare di incorrere in problemi. Infatti, sebbene le operazioni condizionali prevedano comunque di essere mutuamente esclusive ed all’inizio di ogni nuovo loop la variabile i viene ridefinita, il compilatore restituisce un piccolo errore.

Il funzionamento di questa versione è piuttosto semplice ed effettivamente i risultati per questa “incarnazione” del progetto sono abbastanza confortanti: è possibile fornire una segnalazione chiara davvero con poche righe di codice.

Conclusioni e futuri sviluppi

Il più classico dei titoli viene dedicato qui per tirare le somme dell’esperimento.
Questo riconoscitore di colori, è un primo passo verso la realizzazione di un progetto decisamente più complesso ed articolato. Vi abbiamo fatto vedere, questa volta, come lo si può realizzare in maniera semplice, puntando sulla minimizzazione dell’hardware ed ovviamente sulla minimizzazione anche della lunghezza e della complessità del codice implementato.

Per quanto riguarda, però, gli sviluppi futuri, c’è davvero molto da lavorare.

A riguardo, noi abbiamo pensato che il progetto potrebbe essere migliorato innanzitutto, come prima cosa, implementando una funzione di calibrazione, quanto meno creata acquisendo prima una luminosità massima e poi una luminosità minima, per poter anche implementare il riconoscimento di due condizioni (ovvero colori) che non ci sono adesso ovvero “bianco” e “nero”.

Poi c’è da parlare dell’audio. Utilizzare un semplice altoparlante non è certamente una soluzione ottimale. Viceversa sarebbe possibile lavorare con un amplificatore dedicato, per esempio uno schema circuitale così composto:

che realizzi uno schema elettrico di questo tipo:

ed ottenere, come dicevamo, un audio certamente migliore. Per farlo, occorrono:

  • amplificatore operazione LM386 ( o altro dedicato all’audio);
  • 1 condensatore da 220 uF;
  • 1 condensatore da 47 nF;
  • 1 resistenza da 10 Ohm;
  • 1 potenziometro da 10 kOhm.

In questa ultima versione dello schema, inoltre, è stato anche previsto l’utilizzo di un LED RGB che permetta un’ulteriore funzionalità di debug rispetto al colore rilevato (del quale avevamo già accennato). Oltre che a produrre l’output su seriale, infatti, è possibile controllare il LED RGB per fargli riprodurre il colore rilevato. Questa funzionalità, in particolare, sarà molto utile quando i colori da riprodurre e rilevare saranno di più.

Altra possibilità è cambiare il tipo di avvisi acustici perché per questa semplice versione sono stati scelti dei segnali elementari ma, evidentemente, il passo successivo è quello di riprodurre audio più facilmente riconoscibile. Si può lavorare per convertire il segnale vocale ed associarlo al colore riconosciuto facendolo eseguire.

Oltre a queste, che in realtà sono due condizioni nuove, c’è il fatto che il riconoscimento del colore non può fermarsi soltanto a questi colori e con il numero di colori aumenteranno anche (in numero) i files audio che devono essere memorizzati.

Questo vuole anche dire che servirà più spazio in memoria. Se questa volta, infatti, ce la siamo cavata con un codice da poco meno di 4 kB, la prossima volta non saremo certo così fortunati. È necessario, quindi, pensare ad un nuovo modo per memorizzare i dati, onde evitare la saturazione dei 32256 byte disponibili in memoria.

Altra possibilità per migliorare il progetto sarebbe la gestione del volume degli avvisi dopo riconoscimento, grazie all’inserimento di tasti dedicati.

Ed ora la parola voi: che ne dite del progetto? Lo trovate utile?

Come lo modifichereste? Oltre a quelle segnalate, pensate ad altre migliorie? Se sì, quali?

 

Quello che hai appena letto è un Articolo Premium reso disponibile affinché potessi valutare la qualità dei nostri contenuti!

 

Gli Articoli Tecnici Premium sono infatti riservati agli abbonati e vengono raccolti mensilmente nella nostra rivista digitale EOS-Book in PDF, ePub e mobi.
volantino eos-book1
Vorresti accedere a tutti gli altri Articoli Premium e fare il download degli EOS-Book? Allora valuta la possibilità di sottoscrivere un abbonamento a partire da € 2,95!
Scopri di più

15 Comments

  1. IvanScordato Ivan Scordato 16 maggio 2013
  2. Piero Boccadoro Piero Boccadoro 16 maggio 2013
  3. IvanScordato Ivan Scordato 16 maggio 2013
  4. Andres Reyes Andres Reyes 16 maggio 2013
  5. gfranco78 gfranco78 16 maggio 2013
  6. Boris L. 17 maggio 2013
  7. Boris L. 17 maggio 2013
  8. IvanScordato Ivan Scordato 17 maggio 2013
  9. Giorgio B. Giorgio B. 20 maggio 2013
  10. AntonioBlescia AntonioBlescia 20 maggio 2013
  11. Piero Boccadoro Piero Boccadoro 21 maggio 2013
  12. ciccio-1976 22 maggio 2013
  13. Piero Boccadoro Piero Boccadoro 1 giugno 2013
  14. Piero Boccadoro Piero Boccadoro 1 giugno 2013
  15. alessi 1 dicembre 2013

Leave a Reply