Robot hand XBee mano di Gabriele Santin

Siamo giunti all’ultimo articolo dedicato alla robot hand xbee mano di Gabriele, progetto davvero benfatto e molto ben documentato per l’esame di maturità che Gabriele sta sostenendo in questi giorni.

robot hand espositore iLike

Nei precedenti articoli hai letto:

Per cui sai come realizzare nel dettaglio sia la parte relativa ai sensori sia agli attuatori ( servo )

Collegamento e schema elettrico della robot hand xbee mano

Gabriele ha realizzato degli schemi per meglio chiarirti come eseguire i collegamenti dell’XBee e dei servo ad Arduino mediante la robot_shield:

robot hand xbee mano schema fritzing

avrai notato che tutti i servo sono collegati ad uscite PWM, mentre il modulo xbee è connesso ai pin TX ed Rx secondo questo schema:

robot hand xbee adattatore

ingrandito si riconosce chiaramente il partitore di tensione realizzato da Gabriele per adattare il voltaggio proveniente da l pin Tx di arduino ai 3,3v dell’xbee.

Nella realizzazione della mano non ti consiglio di collegare direttamente i servo all’arduino in quanto il loro assorbimento totale sarebbe superiore a quello erogabile da Arduino rischiando di sovraccaricarlo o causare malfunzionamenti dei servo che vibrano per scarsa alimentazione.

Gabriele per prevenire questo ha utilizzato una shield: la robot_shield della futura elettronica:

robot hand XBee elettronica servo shield

che offre i pin per collegare i servo ai PWM di arduino prelevando tensione e corrente da una alimentazione esterna.

Ecco come risulta il collegamento tra la shield ed i servo della robot hand XBee mano assemblata:

robot hand XBee elettronica collegamenti

Lo sketch della mano o ricevitore xbee

lo sketch usato lato ricevitore è:

/*
Robot Hand

Created by Santin Gabriele, 2014
I.T.S.T. "J. F. Kennedy", cl. 5^A EA
*/

#include  <Servo.h>                     // Viene richiamata la libreria
                                        // contenente le funzioni riferite
                                        // al controllo dei servomotori.

Servo ServoPollice, ServoIndice,        // Viene assegnato i
ServoMedio, ServoAnulare, ServoMignolo; // un nome a ciascun servo

byte inizioPacchetto; // Variabile per il controllo di "inizio pachetto". 

byte pollice = 0;     // Dichiarazione delle variabili 
byte indice  = 0;     // che conterrano il valore in 
byte medio   = 0;     // ricezione (tra 0 e 255).
byte anulare = 0;
byte mignolo = 0;

int AngPollice = 0;   // Valori in gradi dell'angolatura 
int AngIndice  = 0;   // che devono assumere i servo
int AngMedio   = 0;
int AngAnulare = 0;
int AngMignolo = 0;


void setup()
{
  Serial.begin(9600);      // attiva la comunicazione seriale a 9600 baud/s.
  Serial.println("Trasmissione attivata.");
  
  ServoPollice.attach(9);  // I servomotori vengono assegnati 
  delay(300);              // ai pin di Arduino UNO.
  ServoIndice.attach(8);   // Si utilizza un ritardo tra 
  delay(300);              // un'assegnazione e l'altra
  ServoMedio.attach(7);    // per un collegamento più 
  delay(300);		   // sicuro dei servomotori.
  ServoAnulare.attach(6);
  delay(300);
  ServoMignolo.attach(5);
  delay(300);
  
  Serial.println("Servomotori pronti."); 
}

void loop()
{ 
  if(Serial.available()) {    // Si attende la ricezione dati dal modulo XBee.
    
    inizioPacchetto=Serial.read(); // La prima variabile sarà 
    pollice = Serial.read();       // il simbolo "<" di inizio.
    indice  = Serial.read();       // Il valore dei sensori 
    medio   = Serial.read();       // viene letto e assegnato alla
    anulare = Serial.read();       // variabile di ciascun dito.
    mignolo = Serial.read();
    
    if(inizioPacchetto == '<'){   // Si verifica che la prima 
				  // variabile corrisponda
                                  // al simbolo "<".
      if(pollice!=255)  AngPollice = map( pollice, 70, 220, 0, 179);
						   
						    
      if(indice!=255) AngIndice  = map( indice , 20, 270, 0, 179);
    
      if(medio!=255) AngMedio   = map( medio  , 40, 210, 0, 179);
    
      if(anulare!=255) AngAnulare = map( anulare, 60, 240, 0, 179);
    
      if(mignolo!=255) AngMignolo = map( mignolo, 25, 210, 0, 179);
    
      ServoPollice.write(AngPollice);  // Ai servomotori viene inviato
      ServoIndice.write(AngIndice);    // il comando di rotazione
      ServoMedio.write(AngMedio);
      ServoAnulare.write(AngAnulare);
      ServoMignolo.write(AngMignolo);
     
     if (n==50)  //rallenta i valori sul monitor seriale
    {  
    Serial.print("Pollice: ");  // i valori ricevuti vengono mostrati 
    Serial.println(pollice);    // ogni secondo per facilitare la lettura
    Serial.print("Indice: ");
    Serial.println(indice);
    Serial.print("Medio: ");
    Serial.println(medio);
    Serial.print("Anulare: ");
    Serial.println(anulare);
    Serial.print("Mignolo: ");
    Serial.println(mignolo);
    n=0;
    }
    else n=n++;
  
   }
  }
  delay(30); // Si introduce un breve ritardo 
	     // per permettere un corretto 
	     // funzionamento dei
}            // servomotori.

leggendolo linea per linea inizia dalle linee 01-06: trovi i commenti e note sull’autore del progetto;

linea 08: includi la libreria servo con la quale potrai controllare in modo semplice i servomotori collegati alla robot hand xbee;

linee 12-13: imposti 5 istanze della libreria Servo.h, una per ciascuna delle dita della mano robot;

linea 15: imposta una variabile di tipo byte che utilizzerai per controllare l’arrivo del primo byte del pacchetto di controllo dei servo;

linee 17-21: definisci 5 variabili di tipo byte in cui memorizzerai i valori provenienti dal modulo xbee;

linee 23-27: definisci 5 variabili di tipo integer in cui memorizzi i valori di angolo che ciascuno dei 5 servo deve raggiungere in funzione del valore ricevuto dalla corrispettiva variabile definita alle linee 17-21;

linee 32-33: imposta la comunicazione con i pin seriali dell’arduino Lilipad su cui riceverai i valori trasmessi dal guanto via xbee;

linea 35: imposta per l’istanza ServoPollice il pin a cui è connesso il servo che si occupa della meccanica del dito pollice;

linea 36: definisci un delay di 300 millisecondi che l’autore consiglia di mantenere per essere certo che il servo sia stato correttamente agganciato dall’istanza

linee 37-44: esegui le medesime operazioni delle linee 35 e 36 per tutte le altre istanze della classe servo;

linea 46: scrivi sul monitor seriale il messaggio “Servomotori pronti”;

linea 51: controlla l’arrivo dei dati dal modulo xbee attraverso la Seriale;

linea 53: leggi il primo byte presente nel buffer seriale e lo memorizzi nella variabile inizioPacchetto che controllerai successivamente;

linee 54-58: leggi in seguenza tutti i valori successivi contenuti nel buffer seriale e momorizzi ciascun valore in una delle variabili di byte corrispondenti alle dita della mano;

linea 60: verifica che nella variabile inizioPacchetto sia contenuto il carattere di controllo ‘<‘ con cui sai iniziare la trasmissione dei valori relativi alla posizione delle dita. In caso di verifica positiva esegui le linee successive altrimenti ignori la ricezione completa di tutto il buffer e riparti dalla prima linea del loop();

linea 63: se il valore della variabile pollice è differente da 255 assegni alla variabile AngPollice il valore a cui posizionare il servo. Per calcolare questo angolo usi nuovamente la funzione map(), già vista nella parte di trasmissione dei valori da parte del guanto, questa volta sai che i valori ricevuti possono variare in un range da 0 a 255 ( quelli stasmessi dal guanto ) e che il servo può posizionarsi in un arco che varia da 0 a 180 gradi ( meglio se 179 per non incorrere in sforzi di finecorsa;

linee 66-72: esegui i medesimi controlli ed assegnazione anche per le altre variabili e valori ricevuti come fatto alla linea 63;

linee 74-78: esegui l’assegnazione di ciascun angolo al servo corrispondente;

linea 80: usa un piccolo trucco per evitare che le linee 82-91 siano scritte sul monitor seriale ad una velocità eccessiva. Il trucco corrisponde nell’inserire un contatore ( n ) che ad ogni ciclo di loop() viene incrementato e che al raggiungimento del valore 50 fa scattare la scrittura delle linee 82-91 resettando poi il valore di n a 0;

linee 82-91: scrivi sul monitor seriale i valori letti dalla seriale e memorizzati nelle variabili alle linee 54-58;

linea 92: resetta il valore di “n” a 0 dopo aver printato le linee preceventi;

linea 94: definisci una condizione di else in cui il ciclo ricade quando n è diversa da 50. In pratica è la linea che continua ad incrementare n fino al raggiungimento del valore 50;

linea 98: introduci un tempo di attesa di 30 millisecondi tra un ciclo loop(9 ed il successivo in modo da dare ai servo la possibilità di posizionarsi correttamente.

Buona sperimentazione !!!

Cortesemente, prima di inserire i commenti leggi il regolamento

Permanent link to this article: http://www.mauroalfieri.it/elettronica/robot-hand-xbee-mano-di-gabriele-santin.html

29 comments

Skip to comment form

    • piero on 8 luglio 2014 at 11:43
    • Reply

    mi complimento per il lavoro di gabriele satin,non mi risulta chiaro il collegamento meccanico delle dita ai servomotori.
    Sarebbe possibile qualche delucidazione? dal servo motore parte un solo filo o uno per l’andata e un ‘altro per il ritorno ?,il dito deve potersi aprire e chiudere e poichè non è rigido non capisco bene il meccanismo.
    ringrazio.
    piero bona

    1. Ciao Piero, lascio a Gabriele la risposta. Ti anticipo solo che hai intuito bene, ci vogliono due fili uno di andata ed uno di ritorno per ciascun dito.
      Puoi chiamarli flessore e tensore il primo flette il dito il secondo lo tende di nuovo.

      • Gabriele on 19 luglio 2014 at 00:50
      • Reply

      Ciao Piero, purtroppo mi è un po’ difficile spiegare bene a parole il funzionamento, proverò a chiarire brevemente.
      Il dito ha due fori verticali per il passaggio del filo, uno davanti e uno dietro rispetto ai perni di rotazione dello stesso. Quando tiri un filo (e lasci l’altro libero) i tre pezzi si chiudono da una parte, quando tiri l’altro (e rilasci il primo) il dito torna dritto. È stato costruito appunto perchè rimanesse dritto, altrimenti si sarebbe piegato anche nel senso opposto, che sarebbe stato abbastanza brutto e strano da vedere 🙂

      Qui ho messo un’immagine con un disegno che ho fatto di recente

      http://media-cache-cd0.pinimg.com/originals/b2/ee/5e/b2ee5e91a8cf310507c439672ea1fe3d.jpg

      Ho calibrato i fili in modo che quando il rotore è in posizione iniziale (verticale) il filo di apertura del dito è tirato (si trova legato nella parte bassa del rotore) e quello di chiusura rilasciato (in alto) e il dito è “dritto”;con la rotazione, quando il rotore è a fine corsa (verticale di nuovo), il filo di chiusura è in trazione e quello di apertura è rilasciato e il dito è piegato.

      Spero di essere stato chiaro 🙂

    • Guido on 21 luglio 2014 at 14:55
    • Reply

    Ciao Gabriele,
    ammiro molto il tuo lavoro!
    sto provando nel tuo stesso modo a leggere un pin analogico, a inviare il segnale, riceverlo per poi muovere un servo.
    sto usando due schede arduino 1, ognuna con un software serial come porta aggiuntiva per la comunicazione, e la porta hardware per la scrittura su monitor seriale.

    come te invio “<" per dare inizio alla lettura
    e poi segue val che è il valore del mio potenziometro.

    i passaggi sono gli stessi ( ridotti per il fatto dei pochi dati da inviare) ma il servo va come gli pare.
    provo e riprovo in mille modi ma nulla.
    avresti qualche consiglio?

    • Thomas on 7 dicembre 2014 at 02:35
    • Reply

    Non ho ben capito una cosa, i due sketch vanno caricati su arduino o sui moduli xbee?

    1. Ciao Thomas, su arduino.
      Gli sketch si caricano sempre su arduino se scritti in linguaggio adatto ad arduino.

    • Lorenzo on 23 febbraio 2015 at 17:16
    • Reply

    Su futuraelettronica la robot shield usata da Gabriele non si trova, quale mi consigliate di usare?
    Grazie.

    1. Ciao Lorenzo,
      si tratta di una shield realizzata proprio da quel rivenditore per cui se non è più disponibile puoi costruirtene una tu o ripiegare per schede simili della pololu a cui dovrai riscrivere la parte software del progetto.

    • Nicola on 27 novembre 2015 at 17:50
    • Reply

    Salve Signor Mauro.. Volevo chiederle dove ha preso e quanto costano i moduli xbee.. poi i fili trasparenti per tirare le dita della mano dove passano? Attendo una sua risposta. Grazie

    1. Ciao Nicola,
      la risposta migliore te la può dare Gabriele, autore del progetto.
      Io i miei componenti li acquisto da robotics-3d.com online.
      I fili mi sembra passino all’interno di ciascun dito.

    • Diego on 4 maggio 2016 at 13:00
    • Reply

    Salve a tutti, vorrei se possibile visionare l’altro sketch che invia dati alla mano.

    1. Ciao Diego,
      trovi entrambi gli sketch pubblicati, usa la funzione “ricerca” in alto a destra del blog.

    • Gennaro on 28 marzo 2017 at 20:18
    • Reply

    salve, non ho capito quante batterie ha usato Gabriele, mica qualcuno me lo può dire? grazie in anticipo

    1. Ciao Gennaro,
      se non vedo male in questa parte del progetto solo una da 9v.

        • Gennaro on 30 marzo 2017 at 14:27
        • Reply

        Grazie mille mauro, quindi non c’è bisogno anche di un’altra batteria per il guanto?!

        1. Ciao Gennaro,
          il guanto avrà la sua alimentazione.

            • Gennaro on 7 maggio 2017 at 12:25

            Ciao Mauro, essendo inesperto ti volevo chiedere se entrambi i moduli xbee vanno configurati… grazie mille in anticipo

          1. Ciao Gennaro,
            si, come descritto negli articoli dedicati all’XBee sul Blog che ti invito a leggere per comprendere come funzionino.

    • Gennaro on 11 maggio 2017 at 07:46
    • Reply

    I due sketch vanno messi insieme sull’arduino giusto?!

    1. Ciao Gennaro,
      no, ovviamente, leggi bene l’articolo e gli articoli correlati.

        • Gennaro on 11 maggio 2017 at 16:13
        • Reply

        Scusami Mauro io non riesco a trovare l’articolo che spiega dove caricare lo sketch del guanto.. Scusami per i disturbi

        1. Prova ad utilizzare la ricerca nel blog, ricordo di averlo pubblicato tutto il progetto di Gabriele.
          In alternativa verifica sui link ai suoi social che dovresti trovare in uno dei suoi articoli o cercando il suo nome su google.

            • Gennaro on 12 maggio 2017 at 15:16

            Ok grazie

    • Gennaro on 21 maggio 2017 at 10:45
    • Reply

    Salve Mauro, nom riesco a venirne fuori da questo problema, mica può spiegarmi dove caricare i due sketch, perché veramente sono arrivato ad un vicolo senza via d’uscita.

    Ps. Ho comprato un addattatore usb uart per xbee per la configurazione

    1. Ciao Gennaro,
      certo, è semplice, lo sketch del guanto va caricato sul guanto, ossia dove hai i sensori.
      Lo sketch presente in questo articolo è relativo alla parte meccanica della mano puoi caricarlo sulla tua realizzazione.

        • Gennaro on 22 maggio 2017 at 15:02
        • Reply

        Quello della parte meccanica l’ho caricato su arduino e ok.. quello del guanto come faccio, devo collegare xbee al computer con l’adattatore usb uart e aprire il programma arduino?? O come si fa a caricarlo sull’xbee del guanto??

        1. Ciao Gennaro, se leggi bene l’articolo e la descrizione, devi avere un arduino anche sul guanto.

    • Gennaro on 23 maggio 2017 at 09:46
    • Reply

    Scusami Mauro ma penso di essere arrivato alla conclusione, ovvero se ho capito il tutto, il programma del guanto lo devo caricare su arduino lilypad, giusto??

    1. Bravissimo Gennaro.

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.