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 !!!

Prima di inserire un commento, per favore, leggi il regolamento

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

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.