Robot Arm serial control

Robot Arm serial control ti permette di controllare i movimenti di un braccio robot a cinematica parallela direttamente dall’interfaccia Seriale.

Facciamo un passo indietro prima di addentrarci nel dettaglio di questo progetto.

Nei mesi scorsi sulla rivista Futura Elettronica è comparso il progetto di un braccio robot realizzato in Plexyglass.

Come spesso accade quando un progetto è interessante e ben fatto ha colpito la mia immaginazione ed ho iniziato a valutarne l’acquisto.

Qualche settimana fa, in occasione dell’ultimo corso arduino avanzato, proprio presso Futura Academy, mi sono procurato il kit del Braccio robotico.

Dopo averlo montato ed eseguiti i primi test seguendo le istruzioni proposte sul sito ho voluto sperimentare con un codice mio la possibilità di gestire il Robot Arm serial control.

Il Robot Arm serial control

Il Robot Arm serial control è un semplice progetto/sketch con cui puoi controllare il tuo braccio robot attraverso il collegamento seriale.

Sfrutti l’interfaccia “monitor seriale” presente nell’IDE arduino per gestire i movimenti dei singoli servo motori e muovere il braccio robot.

La comunicazione seriale da Arduino al computer l’hai letta e conosci da molti dei miei sketch usata come debug per comprendere il funzionamento di sensori e sketch stessi.

In questo articolo userai la comunicazione seriale per impartire, dal monitor seriale, i comandi ai servo come vedi in questo video

Il video ti mostra alcuni movimenti impartiti dal monitor seriale seguendo quello che in informatica si definisce un protocollo: ossia un metodo o linguaggio definito nello sketch e mediante il quale puoi impartire i comandi ai servo.

Quello che ho utilizzato è davvero semplice, usa la sintassi:

[nome del servo][spazio][grado a cui il servo deve posizionarsi]

che nello specifico ipone che se tu vuoi posizionare il servo 2 al grado 90 puoi scrivere semplicemente:

2 90

seguito da invio.

Schema dei collegamenti

Per collegare i 5 servo del robot arm serial control ho utilizzato la shield shield arduino controllo servo e puoi seguire lo schema di collegamento proposto nella documentazione della shield stessa:

In cui i pin S1-S5 sono connessi rispettivamente ai pin D11-D5 PWM di Arduino Uno, come puoi osservare nello schema:

Fonte: Futura Group Srl

per  cui avrai che:

• S1 è collegato al servo di base;
• S2 è collegato al servo denominato “spalla”
• S3 è collegato al servo denominato “gomito”
• S4 è il pin a cui è collegato il servo “polso”
• S5 è il pin a cui è collegato il servo della “pinza” 

Così sarà più chiaro nello sketch a quali pin dovrai collegare le istanze di ciascun servo.

Lo sketch robot arm serial control

Lo sketch Robot Arm serial control parte da un esempio scritto da Arduino “Serial Event”:

da cui puoi copiare la serialEvent() che ti permette di collezionare i dati inviati dall’IDE Arduino mediante interfaccia seriale e collezionare i dati ricevuti in una variabile di tipo String da cui estrarre i dati che ti occorrono.

Ecco lo sketch completo:

#include <Servo.h>

Servo base;         
Servo shoulder;     
Servo elbow;        
Servo wrist_rot;    
Servo gripper;      

byte gBase = 90;
byte gShoulder = 90;
byte gElbow = 90;
byte gWrist = 90;
byte gGripper = 75;

String inputString = "";
bool stringComplete = false;

void setup() {
  Serial.begin(9600);
  
  base.attach(11);
  shoulder.attach(10);
  elbow.attach(9);
  wrist_rot.attach(6);
  gripper.attach(5);

  base.write(gBase);
  shoulder.write(gShoulder);
  elbow.write(gElbow);
  wrist_rot.write(gWrist);
  gripper.write(gGripper);

  inputString.reserve(200);
  Serial.println( "#### START ####" );
}

void loop() {
  if (stringComplete) {
    Serial.print("Rivevuto: ");
    Serial.print(inputString);
    Serial.print(" ");
    switch ( inputString.substring(0,1).toInt() ) {
      case 1:
        Serial.print( inputString.substring(0,1).toInt() ); 
        Serial.print(":");
        Serial.print( inputString.substring(2,5) );
        gBase = inputString.substring(2,5).toInt();
      break;
      
      case 2:
        Serial.print( inputString.substring(0,1).toInt() ); 
        Serial.print(":");
        Serial.print( inputString.substring(2,5) );
        gShoulder = inputString.substring(2,5).toInt();
      break;
      
      case 3:
        Serial.print( inputString.substring(0,1).toInt() ); 
        Serial.print(":");
        Serial.print( inputString.substring(2,5) );
        gElbow = inputString.substring(2,5).toInt();
      break;
      
      case 4:
        Serial.print( inputString.substring(0,1).toInt() ); 
        Serial.print(":");
        Serial.print( inputString.substring(2,5) );
        gWrist = inputString.substring(2,5).toInt();
      break;
      
      case 5:
        Serial.print( inputString.substring(0,1).toInt() ); 
        Serial.print(":");
        Serial.print( inputString.substring(2,5) );
        gGripper = inputString.substring(2,5).toInt();
      break;  
    }
    Serial.print(" "); Serial.print(gBase);
    Serial.print(" "); Serial.print(gShoulder);
    Serial.print(" "); Serial.print(gElbow);
    Serial.print(" "); Serial.print(gWrist);
    Serial.print(" "); Serial.println(gGripper);
    
    inputString = "";
    stringComplete = false;

    base.write(gBase);
    shoulder.write(gShoulder);
    elbow.write(gElbow);
    wrist_rot.write(gWrist);
    gripper.write(gGripper);
  }
}

void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    inputString += inChar;
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

Descrizione dello sketch

Parti dalla prima linea individui l’inclusione della libreria Servo.h che ti permette di inviare comandi ai servo;

linee 003-007: crea 5 istanze della libreria servo, una per ciascun servo che dovrai controllare;

linee 009-013: crea 5 variabili, una per ciascn servo, in cui memorizzerai la posizione iniziale. Nota che il servo della pinza, denominato gripper, non può avere come default 90° come gli altri in quanto la pinza chiude a 75° circa ( nel mio esempio ). Nel tuo montaggio il dato di chiusura della pinza, come di tutti gli altri servo, dovrai verificarlo e impostarlo in queste linee;

linea 015: definisci la variabile di tipo String “inputString” inizialmente vuota;

linea 016: imposta una variabile booleana a false per indicarti se la stringa sia stata correttamente e completamente acquisita;

linee 021-025: esegui l’attach di ciascuna istanza al corrispondente pin di connessione dei servo seguendo lo schema descritto nel paragrafo precedente se hai eseguito i medesimi collegamenti mostrati.

linee 027-031: esegui il posizionamento di ciascun servo usando le impostazioni di base dichiarate alle linee 009-013;

linea 033: imposta un buffer di 200 caratteri per la inputString, anche se in questo esempio al massimo gestiremo 5 caratteri ( uno per il numero del servo, uno per lo spazio, tre per il valore in gradi);

linea 034: invia al monitor seriale la stringa “#### START ####”;

Salta alla linea 095 in cui è presente la funzione serialEvent() ed analizza questa funzione:

linea 096: crea un ciclo while il cui valore discriminante è la disponibilità di dati nello streaming seriale:  Serial.available();

linee 097-098: leggi ciascun carattere dal buffer seriale e memorizzalo prima in una variabile locale di tipo char e successivamente accodalo alla stringa inputString.

linee 099-101: verifica che la stringa sia giunta al carattere “\n”, fine riga, e imposta a true la variabile stringComplete.

Possiamo ritornare alla funzione loop() il cui scopo è valutare ed eseguire le operazioni ricevute via serial;

linea 038: se la variabile stringComplete è true vuol dire che è stato appena letto un buffer e che inputString contiene una stringa da valutare;

linee 039-041: scrivi sul monitor seriale la stringa appena ricevuta;

linea 042: valuta il primo carattere della stringa inputString.substring(0,1).toInt() convertito in intero, come sai è un numero che va da 1 a 5, come i servo installati. In funzione del numero, ossia del servo, ricevuto applichi le linee che seguono il corrispettivo case;

linee 044-046: scrivi sul monitor seriale il primo carattere seguito dal “:” ed il valore in gradi composto da massimo 3 caratteri ( 180° è il valore massimo atteso per questo tipo di servo. Il comando substring ti permette di estrarre parte di una stringa dalla prima posizione di un carattere alla seconda posizione specificata;

linea 047: imposta il valore dei gradi per il servo corrente estraendolo dalla posizione 2 alla 5 della stringa e convertendolo in valore intero con il metodo .toInt();

linee 050-076: eseguono i medesimi passi delle linee appena anlizzate per il caso 1 ma applicate ai servo 2,3,4 e 5;

linee 078-082: scrivi sul monitor seriale i 5 valori impostati in modo da avere sempre sotto controllo tutta la situazione dei servo coinvolti;

linea 084: pulisci la inputString per prepararla alla successiva ricezione;

linea 085: imposta a false il valore di stringComplete per indicare al loop che non ci sono valori da valutare fino alla futura ricezione;

linee 087-091: applica il valore in gradi per ciascun servo al corrispondente servo.

Se tutte le operazioni dello sketch sono andate a buon fine dovrai vedere, scrivendo ad esempio “2 90”, senza virgolette, nel monitor seriale, il servo 2 posizionarsi al grado 90.

Potrai adesso verificare i limiti di movimento dei tuoi servo usando il robot arm serial control ed impartendo da console seriale i valori per ciascun servo.

Prova a seguire i comandi del video per verificare che anche il tuo robot esegua i miei step: