Braccio robotico articolato con Pick & Place

Avrete avuto modo di apprezzare le qualità e potenzialità del braccio robotico con pinza terminale di manipolazione presentato in questo post, per testare il quale abbiamo impiegato una scheda Arduino abbinata a uno shield Octopus.

RoboArm è un braccio robotico in plexiglass con ralla in acciaio, a quattro gradi di libertà (detto quindi antropomorfo, perché si muove praticamente come quello umano); il braccio è di tipo articolato, giacché tutti i giunti sono rotanti, (sono previsti rotazione della base, movimento della spalla, del gomito e la rotazione del polso) che uniti alla pinza all’estremità conferiscono una certa abilità di posizionamento e orientamento di piccoli oggetti.

Il braccio robotico è stato progettato non solo per muovere i primi passi sperimentando e sviluppando applicazioni robotiche, ma può trovare applicazione anche nell’esecuzione di movimenti ripetitivi nel settore produttivo di piccoli oggetti e confezioni.

Nel post introduttivo vi abbiamo spiegato come comandare i servo attraverso Arduino UNO REV3 (o Fishino UNO) equipaggiata con lo shield Octopus, specifico per la gestione dei servocomandi e già descritto nel fascicolo n° 203 di Elettronica In.

Nell’applicazione qui descritta, invece, vi proporremo un’elettronica di controllo dedicata, basata su uno shield ad-hoc predisposto per il controllo dei servocomandi da parte di Arduino, attraverso le uscite PWM, ma anche per acquisire il segnale analogico del potenziometro laddove decidessimo di utilizzare servomotori con feedback di posizione che “portano” all’esterno il segnale del potenziometro coassiale all’alberino.

Tale funzione è utilissima, ad esempio, per i posizionamenti di precisione, giacché consente di correggere eventuali errori o tolleranze dovuti al gioco delle articolazioni, ma anche di apprendere i movimenti per costruire sequenze da eseguire in un secondo momento e automaticamente; l’apprendimento si può effettuare portando il braccio manualmente nelle posizioni desiderate, quindi registrandole e poi inserendole in un firmware che ripeta i relativi movimenti, puntando al raggiungimento degli angoli di rotazione dei servo coinvolti nei movimenti stessi.

Considerate comunque che il sistema funziona tranquillamente anche con dei servocomandi tradizionali, quali quelli compresi nel braccio robotico base descritto nel fascicolo scorso.

Tra le varie funzioni implementate, lo shield si occupa di fornire l’alimentazione ai servo e di comandare l’elettromagnete dell’elettrovalvola e la pompa a depressione che consentono il pick and place.

Prendere e rilasciare oggetti con il braccio robotico

Ciò detto, possiamo entrare nel vivo dell’applicazione, che consiste nell’equipaggiare il braccio robotico di un sistema di prelievo e rilascio di piccoli oggetti basato su una ventosa collegata a un aspiratore (una piccola pompa a depressione) mediante un’elettrovavola, a tre vie, che permette di commutare la ventosa sulla pompa o su uno sfiato; quest’ultimo consente il rilascio immediato dell’oggetto prelevato.

Per limitare il consumo di elettricità da parte dell’elettrovalvola abbiamo scelto di utilizzare il raccordo normalmente collegato al comune per la ventosa e connettere il comune stesso alla pompa a depressione.

Il manipolatore degli oggetti, vale a dire la ventosa, va montata al posto della pinza, la quale andrà quindi rimossa; rimarrà la base, ossia il polso, azionato dal solito servocomando da 1,2 kg/cm che ne consentirà la rotazione per ruotare, all’occorrenza, il pezzo prelevato.

La ventosa è forata all’interno e comunica con un tubicino, il quale va nel raccordo comune dell’elettrovalvola, le cui due vie terminano una sulla pompa a depressione e l’altra su uno sfiato, che consente di portare a pressione atmosferica la ventosa quando la valvola commuta dalla pompa allo sfiato stesso.

La ventosa è sostenuta da uno stelo fissato in cima alla staffa di sostegno (che consente il fissaggio al polso del braccio) mediante un dado che fa presa sul suo estremo filettato; tra la staffa di sostegno e il raccordo pneumatico della ventosa è interposta una molla che consente la presa morbida perché se anche il braccio scende eccessivamente, la ventosa e il suo stelo possono rientrare in una certa misura.

Il funzionamento del sistema di pick & place è il seguente:
1. la ventosa viene posizionata sul particolare da prelevare e spinta sulla superficie di quest’ultimo fino a farla aderire;
2. Arduino aziona, tramite lo shield, la pompa a depressione e, siccome l’elettrovalvola a riposo collega direttamente la ventosa, quest’ultima risucchia il pezzo mantenendolo attaccato ad essa;
3. Arduino comanda il braccio affinché asporti il pezzo e lo posizioni nella sua destinazione;
4. a questo punto Arduino attiva l’elettrovalvola, la quale commuta il raccordo comune sullo sfiato, allorché smette la depressione e l’oggetto può cadere;
5. rilasciato l’oggetto, l’elettronica riporta il braccio nella posizione originaria e si predispone a un nuovo prelievo.

Queste fasi riassumono l’attività del braccio, per eseguire la quale serve un’elettronica comandata manualmente (per esempio tramite due joystick) o in maniera automatica mediante un apposito firmware nel quale memorizzare i movimenti da compiere e la loro velocità, la quale non dev’essere eccessiva per evitare che le giunture (articolazioni) del braccio siano sollecitate tanto da prendere gioco a lungo andare.

In questo articolo vi forniremo uno strumento basilare di gestione del braccio, che consiste in uno sketch per Arduino capace di eseguire il movimento sequenziale di tutti gli azionamenti del braccio ed anche dell’elettrovalvola; in esso basterà sostituire i parametri predefiniti con quelli desiderati per far compiere al braccio robotico le azioni che vogliamo.

Vi spiegheremo come, quando descriveremo il firmware applicativo.

Schema elettrico della shield per il braccio robot

L’elettronica di controllo

Il controllo dei quattro servocomandi del braccio robotico è affidato ad Arduino UNO, attraverso lo shield del quale trovate lo schema elettrico in queste pagine; da esso vedete come si tratti di qualcosa di semplice, riassumibile nel prolungamento delle linee analogiche (1 PWM e un analog input per ciascuno dei servo) di Arduino sui connettori dei servocomandi, che stavolta hanno quattro pin invece di tre, giacché abbiamo aggiunto quello, opzionale, per il feedback di rotazione dell’alberino.

Ciò è possibile perché la scheda Arduino/Fishino UNO dispone di sei uscite PWM e permette il pilotaggio diretto di altrettanti servocomandi, almeno per quel che riguarda i segnali di posizione; l’elettromagnete della valvola a tre vie viene invece gestito attraverso una linea di I/O digitale, che nello shield pilota un transistor utilizzato come interruttore statico.

Lo shield non si limita a fornire i segnali di comando dei servo, ma eroga anche l’alimentazione a 5 V con tutta la corrente che i servocomandi da 13 kg/cm richiedono per funzionare, anche dagli spunti coincidenti con l’avvio dei servocomandi, specie quando il braccio è sotto carico.

Senza utilizzare lo shield avremmo dovuto cablare a parte massa e +5V dei servo, collegando poi i poli + e – a un alimentatore esterno, mentre con lo shield otteniamo un insieme compatto, dato che tutta l’elettronica necessaria al funzionamento del sistema è compresa fra Arduino UNO e lo shield.

Diamo dunque uno sguardo allo schema elettrico dello shield, nel quale, per renderne più semplice la comprensione, al centro abbiamo posto Arduino UNO: come vedete, i connettori di sinistra sono quelli per i servo e su essi viene ripetuta l’alimentazione a 5V prelevata dall’uscita del regolatore di tensione, che vedete siglato U1; S1 è riservato al servocomando 1, S2 al 2 ecc.

Per l’assegnazione dei servo facciamo riferimento alla Tabella 1, che espone la corrispondenza tra essi e la parte del braccio di cui attuano il movimento.

Quest’assegnazione rispecchia quella fatta nel firmware e le due connessioni S5 ed S6 sono state implementate per futuri sviluppi, ovvero per aggiungere funzioni al braccio o gestire servizi correlati alla sua attività.

 

 

Come accennato, ogni connessione ha quattro poli perché, oltre alle due di alimentazione (5V) e all’uscita PWM per il controllo, abbiamo previsto un input di feedback di posizione fornito dai servocomandi.

Quindi per ciascun servo Arduino riserva un’uscita PWM e un ingresso analogico; prendendo ad esempio S1, l’uscita di comando del servo è D11 e l’input di feedback è A0. I connettori per i servo sono ciascuno formato da un pin-strip a 4 poli, la cui piedinatura rispecchia lo standard adottato dai servocomandi con feedback.

Sul lato delle uscite, Arduino UNO pilota due interruttori statici formati da una cascata di transistor BJT e MOSFET a canale N, per azionare l’elettropompa a vuoto e l’elettrovalvola a tre vie, oltre che, direttamente, un LED (LD3, alimentato attraverso la resistenza R9 con l’uscita D13); attraverso D12, invece, è previsto l’interfacciamento con un sensore a uscita digitale, tramite il connettore SENS: si tratta di un sensore presente sulla parte terminale del braccio, che in questa applicazione non viene utilizzato per rilevare quando, facendo scendere la ventosa, questa preme più del dovuto. In pratica il sensore è un microswitch che rileva l’arretramento dell’aspiratore a ventosa, il quale è vincolato alla testa del braccio mediante un sistema a molla che ne consente l’arretramento fino a un certo punto, per assicurare un contatto morbido con il pezzo da manipolare.

Riscrivendo opportunamente il firmware, il sensore può essere un altro a vostra scelta, digitale, che per la comunicazione utilizzi un solo filo (ad esempio un dispositivo 1-wire).

Soffermiamoci un istante sulle uscite OUT1 e OUT2, che sono identiche e quindi descriveremo una sola di esse, fermo restando che quanto spiegato per l’una vale anche per l’altra; prendiamo in esame OUT1, il cui controllo è affidato alla linea D2 di Arduino, la quale, a livello logico alto (5V) tramite il partitore resistivo R1/R2 polarizza la base del T1, mandando quest’ultimo in saturazione, condizione nella quale la tensione Vce quasi si annulla, mandando a livello basso il gate del MOSFET Q1.

Essendo quest’ultimo di tipo enhancement-mode a canale N, rimane interdetto e l’uscita OUT1 non eroga alcuna corrente. Invece quando Arduino pone a zero logico D2, il transistor T1 rimane in interdizione e il gate del Q1 viene alimentato attraverso R3, condizione, questa, che determina l’entrata del MOSFET in stato di ON: la corrente che ora può fluire tra drain del Q1 e massa fa accendere il LED di stato LD1 e alimenta l’eventuale carico connesso tra + e – di OUT1, che forniscono una tensione di circa 5V (la caduta di tensione tra drain e source del MOSFET è trascurabile, almeno alle correnti in gioco).

Passiamo adesso allo stadio di alimentazione, che si basa su una breakout board (U1) basata su’l’integrato WP1584: si tratta di un compatto regolatore di tensione DC/DC di tipo buck, che partendo da una tensione d’ingresso di 12-15V ricava 5Vcc ben stabilizzati, fornendo una corrente di 3A.

Il regolatore ha due contatti d’ingresso (IN+ e IN-) collegati rispettivamente al catodo del diodo di protezione D1 (serve a bloccare la corrente nel caso lo shield venga alimentato per errore con la polarità invertita) e a massa, e due di uscita, che forniscono la tensione stabilizzata.

Lo shield non prende quindi alimentazione da Arduino (infatti nessuno dei pin di alimentazione di quest’ultima scheda è collegato) ma da un jack DC separato a bordo, che nello schema elettrico è siglato PWR; l’alimentazione d’ingresso passata attraverso il diodo di protezione viene filtrata dai condensatori C1 e C2 e quella stabilizzata, a 5 volt, dai condensatori C3 e C4.

Concludiamo l’analisi dello schema elettrico con le linee di I/O D7 e D8 di Arduino, le quali sono input che acquisiscono lo stato dei pulsanti P1 e P2, destinati a future applicazioni, ovvero ad avviare e arrestare l’apprendimento dei movimenti, per esempio.

 

Realizzazione pratica

Bene, passiamo adesso dalla teoria alla pratica occupandoci della costruzione del sistema, partendo dalla premessa che abbiate già assemblato il braccio robotico secondo le istruzioni fornite nel post di presentazione.

Dovete quindi preparare l’elettronica e cablare il tutto secondo lo schema di assemblaggio riportato in queste pagine; più esattamente, una volta realizzato lo shield occorre applicarlo ad Arduino e poi cablare l’elettronica (servo, alimentazione, elettrovalvola e pompa di depressione) nonché realizzare il circuito pneumatico con la pompa a depressione.

Sistemato lo shield applicatelo a una board Arduino UNO rev3 e collocate il tutto sulla piastra di supporto posteriore del braccio, fissandolo mediante colonnine distanziali in plastica alte 8 mm e viti 3MA; connettete quindi i servocomandi ai pin-strip dello shield, tenendone i connettori verso il più vicino header.

Invece, se avete dei servo con feedback e quindi connettore single-in-line a 4 poli, collocateli come previsto. I fili dell’elettropompa a vuoto e della valvola a tre vie (due per entrambi i dispositivi) vanno collegati alle morsettiere OUT1 e OUT2, rispettando la loro polarità; siccome le predette uscite erogano una tensione di 5 volt, la pompa e l’elettrovalvola devono essere a a 5 V.

Piano di montaggio

Elenco componenti

C1: 100 nF ceramico (0805)
C2: 47 µF 16 VL elettrolitico (Ø5mm)
C3, C5: 100 nF ceramico (0805)
C4, C6: 100 µF 6,3 VL elettrolitico (Ø5mm)
R1, R8: 10 kohm (0805)
R2, R3, R6, R7: 4,7 kohm (0805)
R4, R5, R9: 470 ohm (0805)
LD1, LD2: LED rosso (0805)
LD3: LED verde (0805)
Q1, Q2: BUK6215-75C
T1, T2: BC817
P1, P2: Microswitch
D1: GF1M
U1: Modulo DC/DC uscita 5V/3A
S1÷S6: Strip maschio 4 vie
SENS: Strip maschio 3 vie

Varie: 
- Strip femmina 2 vie (4 pz.)
- Strip maschio 2 vie (4 pz.)
- Plug alimentazione
- Morsetto 2 vie passo 5mm (2 pz.)
- Strip 6 vie 15mm
- Strip 8 vie 15mm (2 pz.)
- Strip 10 vie 15mm
- Circuito stampato S1397 (69 x 55mm)

Il manipolatore Pick & Place

Questo è quanto riguarda la parte elettrica ed elettronica, tuttavia affinché il braccio robotico esegua la manipolazione degli oggetti bisogna applicargli al polso il manipolatore pneumatico a ventosa, che si realizza assemblando due piastre in plexiglass da 3 mm come mostrato nella Fig. 1 (dove vedete il corpo con applicata la scheda del microswitch finecorsa, ma priva della ventosa e del suo sostegno a molla) mediante distanziali tubolari da 19 mm in plastica.

Alla piastra superiore in plexiglass va fissata la squadretta a croce fornita col mini servo, utilizzando 4 viti autofilettanti 2×6 TB a croce.

Nel chiudere le due piastre va incastrato il supporto per microswitch, al quale va fissato il circuito (COLLISIONSENS) contenente il microswitch (Fig. 2) che rileva la compressione del sistema a ventosa.

Nel chiudere il corpo delimitato dalle due piastre ricordate che la forcella della guida in plexiglass per il sistema a ventosa deve essere orientata verso la linguetta del microswitch e centrata rispetto al foro della piastra inferiore.

Ora posizionate il polso all’estremità dell’avambraccio facendo combaciare i fori di entrambe le parti e fissarlo all’avambraccio utilizzando una vite M3x35 TB a croce, 4 rondelle piane 3×6, un distanziale in ABS 3×15 e un dado M3 autobloccante.

 

 

Applicate il distanziale squadretta servo (in plexiglass da 3 mm) sulla squadretta a croce mini servo montata sulla testa porta ventosa, posizionate a metà corsa il perno del mini-servo del polso, quindi innestate su di esso la levetta doppia fissata sulla testa porta ventosa in modo che quest’ultima sia allineata con il polso.

Fissate la testa porta-ventosa al perno del servo con la vite autofilettante 2×4 in dotazione al servo, quindi applicate, all’estremità inferiore del supporto ventosa, la ventosa più adatta alle vostre necessità.

Applicate al terminale C dell’elettrovalvola un’estremità del tubetto in silicone fornito col kit.

Distendete e fissate il tubetto lungo il braccio in modo che l’estremità libera possa raggiungere la testa porta-ventosa senza creare impedimento ai movimenti.

Per completare il lavoro, spingete l’estremità del tubetto sul raccordo del supporto ventosa (tenendolo con una mano per evitare di far forza sulla testa porta-ventosa).

Il tubetto in silicone può essere eventualmente accorciato ma prima è necessario verificare che sia in grado di raggiungere la testa porta-ventosa anche nelle condizioni più estreme (massima e minima estensione del braccio, ecc.) senza subire strozzature che ridurrebbero la forza aspirante.

Ora il montaggio delle parti meccaniche del braccio è terminato. Non resta che distendere ed eventualmente prolungare (con cavi M/F) i cavetti elettrici di ciascun servo in modo da fargli raggiungere la scheda di controllo senza interferire con le parti in movimento.

 

Schema di cablaggio per braccio robotico

Il firmware del robot arm

Ora è il momento di approcciare agli aspetti firmware descrivendo lo sketch che abbiamo preparato ad-hoc per far funzionare il braccio robotico e spiegandovi come impostarne i parametri allo scopo di far eseguire al braccio i movimenti desiderati.

Il firmware comprende una serie di sezioni che descrivono il movimento, inteso come rotazione del servo e tempo impiegato ad ottenerla, una per ciascuno dei servo che lo shield può gestire, quindi 6.

Per realizzare una sequenza, basta quindi personalizzare tali parametri e allo scopo ricordate che bisogna far compiere i movimenti fino all’angolazione desiderata per ciascun servo, registrare l’angolazione, quindi collegare Arduino a PC, editare parametri dello sketch, quindi ricaricare lo sketch e far eseguire in loop.

Lo sketch è riportato nel Listato 1 e sostanzialmente esegue la sequenza di posizionamento della testa pneumatica, passando dalla posizione di partenza A, portandosi alla B (dove si trova il pezzo), facendo scendere la testa, azionando la pompa a depressione (l’elettrovalvola è a riposo, grazie all’istruzione digitalWrite(valve, HIGH) e quindi risollevando la testa e portandosi di nuovo in posizione A, nella quale rilascia il pezzo attraverso l’interruzione della depressione, operata alimentando l’elettrovalvola (digitalWrite(valve, LOW) e portando in OFF la pompa.

Il tutto è ottenuto sfruttando le librerie braccio.h e servo.h che gestiscono in toto i movimenti.

Ogni istruzione ServoMovement determina lo spostamento dei servocomandi che devono essere scritti tra parentesi, separati dalla virgola e preceduti dal tempo impiegato a compierli. Ad esempio (40, 120, 110, 90 ecc.) indica che le posizioni in gradi devono essere raggiunte in un tempo pari a 40.

Listato 1

#include <Braccio.h>

#include <Servo.h>

#define pump 2
#define valve 4

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

// the setup function runs once when you press reset 
// or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(pump, OUTPUT);
  pinMode(valve, OUTPUT);

  digitalWrite(pump, HIGH);
  digitalWrite(valve, HIGH); //HIGH ASPIRA LOW RILASCIA

  //For each step motor this set up the initial degree

  Braccio.begin();
}

void loop() {
  //vado in posizione A
  Braccio.ServoMovement(40, 120, 110, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 60, 90, 100, 90, 90);
  delay(500);
  Braccio.ServoMovement(40, 120, 60, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 60, 100, 100, 90, 90);
  //mi abbasso e dico no no 
  Braccio.ServoMovement(10, 120, 60, 100, 50, 90, 90);
  //no no
  Braccio.ServoMovement(10, 120, 60, 100, 150, 90, 90);
  Braccio.ServoMovement(10, 120, 60, 100, 50, 90, 90);
  Braccio.ServoMovement(10, 120, 60, 100, 90, 90, 90);
  delay(1000);
  // vado in posizione B e mi abbasso
  Braccio.ServoMovement(40, 120, 110, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 70, 60, 90, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 60, 110, 90, 90, 90);
  //faccio partire la pompa
  digitalWrite(valve, HIGH);
  digitalWrite(pump, LOW);
  delay(1000);
  //mi alzo
  Braccio.ServoMovement(40, 70, 60, 90, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 110, 90, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 110, 90, 50, 90, 90);

  //Vado in posizione A 
  delay(1000);
  Braccio.ServoMovement(40, 120, 110, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 60, 90, 100, 90, 90);
  delay(500);
  // mi abbasso
  Braccio.ServoMovement(40, 120, 60, 110, 100, 90, 90);
  //spengo la pompa 
  digitalWrite(valve, LOW);
  digitalWrite(pump, HIGH);
  delay(1000);
  //mi alzo
  Braccio.ServoMovement(40, 120, 90, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 90, 90, 90, 90, 90);

  //Vado in posizione B
  delay(1000);
  Braccio.ServoMovement(40, 70, 60, 80, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 60, 100, 90, 90, 90);
  //Mi abbasso
  delay(1000);
  //e dico no no
  Braccio.ServoMovement(10, 70, 60, 100, 50, 90, 90); //no no
  Braccio.ServoMovement(10, 70, 60, 100, 150, 90, 90);
  Braccio.ServoMovement(10, 70, 60, 100, 50, 90, 90);
  Braccio.ServoMovement(10, 70, 60, 100, 90, 90, 90);
  //Wait 1 second
  delay(1000);
  //mi rialzo e vado in posizione A
  Braccio.ServoMovement(40, 120, 110, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 60, 90, 100, 90, 90);
  delay(500);
  //mi abbasso
  Braccio.ServoMovement(40, 120, 60, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 60, 110, 100, 90, 90);
  //e faccio partire la pompa
  digitalWrite(valve, HIGH);
  digitalWrite(pump, LOW);
  delay(1000);
  //mi alzo
  Braccio.ServoMovement(40, 120, 90, 90, 100, 90, 90);
  Braccio.ServoMovement(40, 120, 90, 90, 90, 90, 90);

  //Wait 1 second
  delay(1000);
  //vado in pos B
  Braccio.ServoMovement(40, 70, 60, 90, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 60, 110, 90, 90, 90);
  digitalWrite(valve, LOW);
  digitalWrite(pump, HIGH);
  //dico no no
  delay(1000);
  Braccio.ServoMovement(40, 70, 60, 90, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 110, 90, 90, 90, 90);
  Braccio.ServoMovement(40, 70, 110, 90, 50, 90, 90);
  //Wait 1 second
}

Conclusioni

Il progetto qui descritto è un’applicazione scalare, nata come demo delle possibilità di manipolazione offerte dal nostro braccio robotico, ma estensibile a qualsiasi applicazione e a qualsiasi tipo di braccio robotico simile per gradi di libertà e attuazione.

Si tratta solo di mettere mano al firmware e partendo da questa base si possono realizzare applicazioni complesse, che escono dal mondo della didattica, per approdare al professionale.