Diamo una vista a Xduino

 

Pubblicato il: 24 giugno 2010 @ 13:42

Riportando quanto già da me iniziato nel forum italiano di Arduino, con questo articolo cercherò di organizzare e dare corpo a un progettino, forse un po ambizioso, ma secondo me fattibile:
dare una primordiale vista ad un Xduino *1.

L’idea mi venne dopo aver scovato in rete alcuni articoli e progettini che sfruttavano il sensore ottico di un vecchio mouse (optical mouse), che a differenza di una comune webcam *2 possiede una risoluzione di circa 18×18 pixel (in alcuni modelli leggermente diversa) e la possibilità di collegarla mediante una semplice interfaccia seriale *3. Così avrei potuto sfruttare questa piccola e comoda periferica come un vigile “occhio” capace di individuare eventuali oggetti/persone in movimento.

Ma cosa te ne fai? direte voi…

… Un giochino! :-)

Un gadgettino che grazie al suo occhio nascosto riesca a muovere una “testa” mediante due piccoli ed economici servo motori e due piccole matrici di led per simulare degli “occhi” con alcune diverse espressioni. E tutto cercando di spendere il meno possibile utilizzando anche molto materiale di recupero!

Per far capire meglio l’obiettivo: chi non ha mai visto gli occhi che seguono il mouse ??

Bene, immaginate che si tratti invece di una “testa” che si muove in direzione di chi o cosa gli passa davanti cambiando espressione a seconda di diverse condizioni! Ed immaginatevelo magari all’interno di una vetrina che segue con lo sguardo i passanti… una situazione che non può che incuriosire parecchio (chi, sentendosi osservato, non si ferma incuriosito per capire cosa stia accadendo?).

Ebbene, per realizzare il tutto ho pensato che deve essere esclusivamente gestito da una schedina come Xduino *1 e quindi senza alcun aiuto da parte di un computer (ovvero: nessuna connessione esterna e nessun collegamento radio).

Iniziamo la realizzazione:

Come ho già detto, il sensore al quale avevo pensato è quello presente all’interno di alcuni mouse ottici. Però non in tutti questi componenti (che hanno varie caratteristiche fisiche, di interfacciamento o precisione) esiste la disponibilità di ricevere anche l’immagine. Così ho preparato un piccolo elenco (probabilmente incompleto) che possa essere utile. E se siete i fortunati possessori di un vecchio mouse ottico potete anche verificare se si tratti di uno di questi:

Sensore     Matrice      Test effettuato
ADNS-5020   225pixel
ADNS-2051   256pixel      si
ADNS-2030   256pixel      si (compatibile 2051 ma a 3.3V)
ADNS-2610   324pixel
ADNS-2620   324pixel

Come si vede per alcuni sensori idonei esiste già del codice utile ad eseguire il test del sensore. Nel caso dei sensori 2051 e 2030 ho trovato questo codice funzionante (che per comodità ho “tradotto” dall’originale) dal forum di Arduino nella sezione francese:

/*
MouseCam basato su code di Benoît ROUSSEAU
(forum Arduino: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1154816099)
*/

#define SCLK 2
#define SDIO 3

//Prototipi di funzione
byte LetturaRegistro(byte indirizzo);
void ScritturaRegistro(byte indirizzo, byte dato);
void LeggiImmagine();

void setup()
{
  pinMode (SCLK, OUTPUT);
  pinMode (SDIO, INPUT);
  Serial.begin(19200);
}

void loop(){
  if(LetturaRegistro(0x02))
  {
    Serial.print('>');
    Serial.print(LetturaRegistro(0x00), DEC);
    Serial.print('-');
    Serial.print(LetturaRegistro(0x01), DEC);
    Serial.print('-');
    Serial.print(LetturaRegistro(0x03), DEC);
    Serial.print('-');
    Serial.print(LetturaRegistro(0x04), DEC);
    Serial.println();
  }
  if (Serial.available())
  {
    Serial.read();
    LeggiImmagine();
  }
}

byte LetturaRegistro(byte indirizzo){
  int i = 7;
  byte ritorno = 0;
  pinMode(SDIO, OUTPUT);
  for(; i>=0; i--){
     digitalWrite(SCLK, LOW);
     digitalWrite(SDIO, indirizzo & (1 << i));
     digitalWrite(SCLK, HIGH);
  }
  pinMode(SDIO, INPUT);
  delayMicroseconds(100);
  for(i=7; i>=0; i--){
    digitalWrite(SCLK, LOW);
    digitalWrite(SCLK, HIGH);
    ritorno |= (digitalRead (SDIO) << i);
  }
  delayMicroseconds(100);
  return ritorno;
}

void ScritturaRegistro(byte indirizzo, byte dato){
  int i = 7;
  indirizzo |= 0x80;
  pinMode(SCLK, OUTPUT);
  for(; i>=0; i--){
     digitalWrite(SCLK, LOW);
     digitalWrite(SDIO, indirizzo & (1 << i));
     digitalWrite(SCLK, HIGH);
  }

  for(i=7; i>=0; i--){
     digitalWrite(SCLK, LOW);
     digitalWrite(SDIO, dato & (1 << i));
     digitalWrite(SCLK, HIGH);
  }
}

void LeggiImmagine(){
  byte val;
  byte adr;
  Serial.print(">IMG:");
  ScritturaRegistro(0x0a, 0x09);
  for(int i=0; i<256; i++)
  {
    do{
     adr = LetturaRegistro(0x0d);
     val = LetturaRegistro(0x0c);
    } while(val & 0x80);
    Serial.print(" ");
    Serial.print(val, HEX);
  }
  Serial.println();
  ScritturaRegistro(0x0a, 0x00);
}

 

QUI trovate altra documentazione utile (purtroppo in inglese .. ).

Per il sensore ADNS-2620, che è ancora reperibile e in vendita per pochi euro, non appena ne riceverò uno vedrò di scrivere io stesso la libreria per il collegamento con Xduino.

Come usare il codice sopra riportato è semplice: copiare ed incollare il codice nell’IDE di Arduino (e sto parlando del software che permette ad un Xduino di “agire”), procedere al caricamento del vostro Xduino opportunamente collegato al computer e al quale avrete collegato il vostro sensorino del mouse come indicato nel codice (all’inizio viene spiegato come sono i collegamenti). Dopo di che, attivando il monitor sella seriale su Arduino IDE, se muoverete il vostro mouse dovreste vedere la ricezione delle coordinate X e Y dal mouse, e inviando un qualsiasi tasto ricevere il frame (l’immagine) corrente che il mouse ha analizzato (non certo come immagine ma come un lungo elenco di valori corrispondenti alla luminosità di ciascun punto).

Nei prossimi articoli vedremo come dare un “espressione” al nostro esperimento… (che nome gli diamo?), poi passeremo alle prove su Processing per testare l’algoritmo di riconoscimento ed emulare il sensore così da escludere problemi almeno nel codice, quindi passeremo alla gestione dei servi, alla gestione degli array di led e alla realizzazione pratica ;)

NOTE AL TESTO:
*1 (in questo blog Xduino è sinonimo sia della scheda hardware Arduino che di un qualsiasi suo clone compatibile)
*2 (una normale webcam ha una risoluzione minima di 640×480 pixel, il che comporta parecchia memoria per gestirla, cosa che il nostro Xduino da solo non ha)
*3 (l’interfaccia usata è la PS/2 (IBM Personal System/2), l’interfaccia seriale che collegava tastiere e mouse nei comuni PC prima dell’arrivo della USB)

Tag: