mano robot servo flex sensor

La mano robot sevo e flex sensor è l’evoluzione degli articoli pubblicati nei giorni scorsi e fa parte di un progetto realizzato con la collaborazione dell’ITIS di Vorbano e degli allievi del prof. caruccio.

Per ralizzare il progetto abbiamo selezionato i componenti che puoi acquistare:

• n.1 arduino uno
• n.1 protoshield
• n.6 morsetti da scheda
• n.3 headers per la protoshield
• n.1 connettore maschio da 20 pin da scheda
• n.5 sensori di flessione
• n.5 resistenze da 10Kohm
• n.5 servomotori modellistici
• n.1 ponticello per pin da scheda

da robot-domestici ed ho provveduto alla realizzazione del circuito sulla protoshield.

I collegamenti su protoshield della mano robot servo flex sensor

I sensori di flessione hanno 2 contatti ciascuno e per poter essere collegato agli ingressi analogici di arduino è necessario aggiungere una resistenza da 10Kohm tra uno dei terminali del sensore e il polo positivo del circuito.

I servo puoi collegarli direttamente ai pin di tipo PWM di arduino avendo cura di alimentare tutti i servo attraverso una pila esterna in grado di erogare 5v e almeno 1000mA per evitare il tremolio o la cattiva risposta in velocità da parte dei servo.

I pin che ho scelto per il progetto sono 5,6,9,10,11 rispettivamente per mignolo, anulare, medio, indice e pollice.

La protoshield mano robot servo flex sensor

Puoi osservare la protoshield realizzata per il progetto sia dal lato alto:

sia dal suo lato inferiore:

lo sketch

#include <Servo.h> 

/****************************************************/

#define sensPollice A5
#define sensIndice A4
#define sensMedio A3
#define sensAnulare A1
#define sensMignolo A2

/****************************************************/

#define pinPollice 11
#define pinIndice 10
#define pinMedio 9
#define pinAnulare 6
#define pinMignolo 5

/****************************************************/

Servo police;
Servo indice;
Servo medio;
Servo anulare;
Servo mignolo;

/****************************************************/

int valuePollice = 0;
int valueIndice = 0;
int valueMedio = 0;
int valueAnulare = 0;
int valueMignolo = 0;

/****************************************************/

int rangePollice[] = {130,270};
int rangeIndice[] = {130,270};
int rangeMedio[] = {130,270};
int rangeAnulare[] = {130,270};
int rangeMignolo[] = {130,270};

/****************************************************/

int gradiPollice[] = {0,180};
int gradiIndice[] = {0,180};
int gradiMedio[] = {0,180};
int gradiAnulare[] = {0,180};
int gradiMignolo[] = {0,180};

/****************************************************/

void setup() {
  Serial.begin(9600);
  pinMode( sensPollice,INPUT );
  pinMode( sensIndice,INPUT  );
  pinMode( sensMedio,INPUT   );
  pinMode( sensAnulare,INPUT );
  pinMode( sensMignolo,INPUT );

  police.attach( pinPollice   );
  indice.attach( pinIndice    );
  medio.attach(  pinMedio     );
  anulare.attach( pinAnulare );
  mignolo.attach( pinMignolo  );

  police.write( gradiPollice[0]   );
  indice.write( gradiIndice[0]    );
  medio.write(  gradiMedio[0]     );
  anulare.write( gradiAnulare[0] );
  mignolo.write( gradiMignolo[0]  );

}

/****************************************************/

void loop() {

  valuePollice = map(analogRead(sensPollice), rangePollice[0], rangePollice[1], gradiPollice[0], gradiPollice[1]);
  valueIndice  = map(analogRead(sensIndice), rangeIndice[0], rangeIndice[1], gradiIndice[0], gradiIndice[1]);
  valueMedio   = map(analogRead(sensMedio), rangeMedio[0], rangeMedio[1], gradiMedio[0], gradiMedio[1]);
  valueAnulare = map(analogRead(sensAnulare), rangeAnulare[0], rangeAnulare[1], gradiAnulare[0], gradiAnulare[1]);
  valueMignolo = map(analogRead(sensMignolo), rangeMignolo[0], rangeMignolo[1], gradiMignolo[0], gradiMignolo[1]);

  police.write( valuePollice   );
  indice.write( valueIndice    );
  medio.write(  valueMedio     );
  anulare.write( valueAnulare  );
  mignolo.write( valueMignolo  );

  delay( 200 );
}

il principio di funzionamento della mano robot è semplice: ciascun sensore di flessione invia il segnale letto ad arduino a cui hai insegnato a riconoscere il valore a sensore disteso e piegato, in funzione di questo valore controlli la rotazione del servo dal grado minimo impostato al grado massimo, ecco nel dettaglio per ciascun dito:

linee 05-09: definisci i pin a cui hai collegato i sensori, un sensore per ciascun pin;

linee 13-17: definisci i pin a cui hai collegato i servo, seguendo lo schema sopra;

linee 21-25: definisci le istanze di tipo Servo per ciascun dito;

linee 29-33: imposta i valori di angolo iniziale dei servo;

linee 37-41: imposta il range di valori minimo e massimo che ciascun sensore può restituirti, come avrai notato sono distinti per ciascun sensore per consentirti di impostare i valori dettagliati;

linee 45-50: imposta i range di movimento per ciascun servo, in questo modo se un servo deve compiere un movimento inferiore alla massima escursione del servo puoi definirlo nella variabile corrispondente;

linee 55-71: inizializza i pin a cui sono connessi i sensori, i pin a cui sono attaccati i servo con il metodo attach() e posiziona i servo in posizione di partenza;

linee 79-88: leggi i valori analogici restituiti dai sensori e ricava con la funzione map() la corrispondenza tra valore minimo e massimo letto dal sensore e la rispettiva rotazione del servo in gradi;

linee 90-94: imposta il valore in gradi al servo che controlla il movimento del dito;

linea 96: attendi 200 millisecondi tra un movimento ed il successivo, puoi ridurre questo tempo fino al minimo tempo necessario dai tuoi servo a raggiungere la posizione desiderata.

Il video

Ecco il video della demo fatta prima di inviare tutto all’ITIS di Vorbano: