Robot arm sketch test

Robot arm sketch test ti mostra il primo sketch che puoi utilizzare per controllare il tuo cobot.

La prima fase dell’utilizzo di un cobot è l’apprendimento delle posizioni e delle operazioni che deve eseguire, siano esse in tempo reale ( guida specchio ) o registrate per essere eseguite in modo ripetitivo.

Lo sketch che leggerai di seguito serve a due principali scopi:

• verificare che tutti i componenti del robot siano correttamente posizionati e inviino i dati ad arduino;
• far muovere il robot in modo sincrono con il controller;

per far questo devi aver già realizzato le parti stampate in 3D ed i corretti collegamenti descritti nello schema. Tutti i passaggi li trovi nella serie di articoli dedicati al robot arm:

• Robot arm 3D printed
• Robot arm 3D printed openscad
• Robot arm controller
• Robot arm schema
• Robot arm montaggio

al termine del motaggio dei componenti e della realizzazione dello schema elettronico è giunto il momento di programmare il robot arm con un primo sketch.

Robot arm sketch test

Il primo sketch che ti propongo è quello che permette, come hai letto, di eseguire il test dei motori, dei potenziometri e dei movimenti del robot.

Ecco lo sketch:

#include <Servo.h>

#define potBase     A5
#define potGrip     A4
#define potShoulder A3
#define potWrist    A2
#define buttRec     A1
#define buttPlay    A0

Servo servoBase;
Servo servoShoulder;
Servo servoWrist;
Servo servoGrip;

int coBase     = 0; 
int coGrip     = 0; // 25 - 80 
int coShoulder = 0; 
int coWrist    = 0; 
int coRec      = 0; 
int coPlay     = 0; 

void setup() {
  Serial.begin( 115200 );
  
  pinMode( potBase,INPUT );
  pinMode( potGrip,INPUT );
  pinMode( potShoulder,INPUT );
  pinMode( potWrist,INPUT );
  pinMode( buttRec,INPUT );
  pinMode( buttPlay,INPUT );

  servoBase.attach(9);
  servoShoulder.attach(6);
  servoWrist.attach(5);
  servoGrip.attach(3);

  coBase     = 512;
  coShoulder = 85;
  coWrist    = 52;
  coGrip     = 25;

  moveServos();
  delay( 1000 );
}

void loop() {
  mapping();
  writeSerial();
  
  moveServos();

  delay( 15 );
}

void mapping() {
  coBase     = map(analogRead( potBase ),     0, 1023, 0, 180);
  coShoulder = map(analogRead( potShoulder ), 0, 1023, 0, 180);
  coWrist    = map(analogRead( potWrist ),    0, 1023, 0, 180);
  coGrip     = map(analogRead( potGrip ),     0, 1023, 0, 180);

  if (coGrip <=25) coGrip = 25;
  if (coGrip >=80) coGrip = 80;
  
  if (analogRead( buttRec )  == 0 )  coRec = 0; else coRec  = 1;
  if (analogRead( buttPlay ) == 0 ) coPlay = 0; else coPlay = 1;
}

void moveServos() {
  servoBase.write(     coBase ); 
  servoShoulder.write( coShoulder ); 
  servoWrist.write(    coWrist );
  servoGrip.write(     coGrip ); 
}

void writeSerial() {
  Serial.print("\tB: "); Serial.print( coBase ); 
  Serial.print("\tG: "); Serial.print( coGrip ); 
  Serial.print("\tS: "); Serial.print( coShoulder ); 
  Serial.print("\tW: "); Serial.print( coWrist ); 
  Serial.print("\tR: "); Serial.print( coRec ); 
  Serial.print("\tP: "); Serial.print( coPlay );
  Serial.println();
}

La prima linea include la libreria Servo che userai per controllare i servo motori;

linee 03-08: imposta ele definizioni dei pin a cui sono connessi i 4 potenziometri, rispettivamente connessi a base,pinza,spalla e polso, ed i due pulsanti.

Avrai notato anche nello schema proposto in un precedente articolo:

che ho deciso di collegare i due pulsanti ai pin analogici e gestirli leggendo i valori 1023 o 0 in base al loro stato. La scelta è del tutto arbitraria e dettata dalla semplice comodità dei collegamenti da eseguire sulla mia basetta millefori.

linee 10-13: definisci per ciascun servo motore una istanza della libreria servo corrispondente;

linee 15-20: imposta 6 variabili di tipo intero che userai per memorizzare i valori di posizione da inviare ai servo motori e per il controllo dello stato dei pulsnati;

linea 23: imposta la comunicazione seriale a 115200 baud;

linee 25-30: per ciascun pin in ingresso ( i pin A0-A5 a cui sono collegati i potenziometri ed i pulsanti ) imposta la modalità INPUT su arduino;

linee 32-35: usando il metodo attach per ciascuna istanza servo collega quest’ultima al pin del servo corrispondente in modo che tu possa controllarli con i metodi della libreria Servo.h;

Alle linee 27-40: imposti dei valori di default di posizione da far raggiungere ai servo in fase di stat;

linea 42: richiami la funzione moveServos() che esegue lo spostamento dei servo nelle posizioni definite alle linee precedenti;

linee 47-50: richiami in sequenza le funzione mapping(), writeSerial() e moveServos() che analizzerai di seguito;

linea 52: per ciascun ciclo del loop() attendi 15 millisecondi prima di eseguire il ciclo successivo, serve ad eseguire gli spostamenti dei servo motori;

linea 55: definsci al funzione mapping();

linee 56-59: imposti i valori di posizione di ciascun servo rimappando i valori letti sui potenziometri in angoli da trasferire ai servo motori;

linee 61-62: controlla che la posizione del coGrip sia compresa tra 25 e 8o in modo da non sovraccaricare la chiusura e apertura della pinza;

linea 64: converti in 0 e 1 i valori letti da 0 a 1023 sul pulsante Rec;

linea 65: converti in 0 e 1 i valori letti da 0 a 1023 sul pulsante Play;

Come hai notato la funzione mapping() serve a convertire i valori letti su potenziometri e pulsanti in valori coerenti da passare ai servo ed allo sketch;

linea 68: definisci la funzione moveServos() che servirà a posizionare i servo nella corretta posizione;

linee 69-72: per ciascun istanza dei servo imposti il corrispondente valore di posizione da raggiungere;

linea 75: definisci la funzione writeSerial() che scrive sul monitor seriale i valori di posizione dei servo così come li hai impostati;

linee 76-82: per ciascun valore di posizione dei servo motori e dei pulsanti scrivi sul monitor seriale una linea contenente tutti i valori corretti.

La funzione writeServo(), in questa fase, è fondamentale per consentirti di verificare e correggere eventuali limiti oltre i quali non vuoi che i servo operino;

Leggendo il monitor seriale riuscirai a vedere quali posizioni, numeriche, ogni servo assume e procedere alle necessarie correzioni.

Nei prossimi articoli dedicati al robot arm proverai altri sketch che possono essere utili per far compiere al tuo cobot le operazioni ripetitive di posizione.

Con il robot arm sketch test puoi già provare a controllare il robot in modo che ad ogni spostamento del controller il braccio esegua un corrispondente spostamento.

Ti ricordo che il progetto è condiviso su Thingiverse.