Tutorial #12 – Robotic Hand
Materiale utilizzato – Arduino UNO – 5 servo motori – 5 sensori di flessione – 5 resistenze – alimentatore esterno da 12V – materiale per costruire la mano robotica (tubi, carta, colla, filo, etc…) – guanto.
Per vedere tutti i tutorial: www.marcopucci.it/arduino/
Segui la pagina Tutorial Arduino su Facebook
N.B: Clicca qui per scaricare il file .zip con tutti gli sketch utilizzati per realizzare la mano robotica.
In questo tutorial realizziamo una mano robotica (low cost) in grado di replicare i movimenti della nostra mano.
Inseriamo dei sensori di flessione sulle dita di un guanto, analizziamo il valore di questi sensori e muoviamo dei servo motori 180° che tirano un filo collegato a ciascun dito della mano robotica.
La parte elettronica consiste quindi nella creazione di un guanto con sensori e la mano robotica con i cinque motorini.
Se non avete mai utilizzato i servo motori vi consiglio di leggere il tutorial n. 8 – clicca qui.
Procediamo con la realizzazione del guanto.
I sensori di flessione (immagine sopra) sono delle piccole barrette flessibili che indicano la quantità di flessione a cui sono sottoposti. Attaccandoli alle dita del guanto sappiamo esattamente il movimento di ciascun dito.
I sensori di flessione devono essere collegati ad Arduino con delle resistenze. Possono essere acquistati online sul sito di Robot-Italy.
Sensore: www.robot-italy.com/it/flex-sensor-2-2.html – 8 euro
Resistenze: www.robot-italy.com/it/resk-kit-500-resistenze.html – 5 euro (kit da 500)
Altrimenti potete acquistare in qualsiasi negozio di elettronica delle resistenze da 2.2 Kohms
Questo tutorial è stato realizzato nel 2014, prima di procedere all’acquisto online verificate se altri siti più convenienti vendono i sensori di flessione. Attualmente questo segnalato è il più economico.
Il sensore di flessione deve essere collegato in questo modo: la barra laterale più stretta deve essere alimentata con i 5V di Arduino. La barra più grande deve essere collegata al GND di Arduino passando per una resistenza. Il cavo che arriva al pin analogico di Arduino (serve per leggere il valore del sensore) deve essere saldato prima della resistenza (guardare lo schema qui sopra). A cosa serve la resistenza?
In questo caso la resistenza serve per diminuire e rendere leggibile il valore del sensore.
Inserendo una resistenza di 2.2 Kohms avremo come lettura analogica un valore uguale a 50 se il sensore non è piegato, uguale a 90 se il sensore è flesso in una direzione e un valore uguale a 10 se il sensore viene piegato nel senso inverso.
Qui sotto un piccolo schema per vedere i valori del sensore di flessione.
N.B: se utilizzate un altro tipo di resistenza questi valori saranno diversi.
VALORE SENSORE = 50
VALORE SENSORE = 10
Iniziamo con un solo sensore. Realizzate il circuito elettrico della pagina precedente e aprite il software di Arduino per iniziare a programmare. Per il momento non utilizziamo né il guanto né la mano robotica.
L’assemblaggio verrà realizzato alla fine, quando il codice e il circuito di un singolo dito saranno completati.
INFORMATICA
Per testare il funzionamento del sensore apriamo il file presente all’interno del programma di Arduino per la lettura analogica del sensore (FILE – ESEMPI – BASIC – ANALOGREADSERIAL).
Questo sketch permette di leggere qualsiasi sensore posizionato nel pin 0 di Arduino.
Se non avete mai visto questo codice fermatevi qui e iniziate tutto il corso di Arduino dal tutorial n1 – clicca qui
Uplodate il codice sulla scheda e aprite il Serial Monitor.
Tenendo il sensore fermo il numero visualizzato dovrebbe essere un 50.
Piegandolo in avanti raggiungete il numero 10, piegandolo nel senso inverso il numero 90.
Se avete utilizzato una resistenza diversa il valore cambia.
Segnatevi i valori del sensore fermo e piegato in avanti. Dovrete sostituirli a quelli che utilizzerò io nel tutorial.
COMANDO MAP (Aprite lo sketc _2_1_sensore_1_motore_val)
Passiamo ora ai motori servo.
Colleghiamo un servo ad Arduino seguendo lo schema qui sotto.
Quando il sensore di flessione verrà piegato, il motorino si muoverà in maniera proporzionale.
Abbiamo già visto che con il comando myservo.write(90); possiamo muovere il nostro servo in un angolo qualsiasi compreso tra 0 e 180°. Esiste un comando nel programma di Arduino che ci permette di passare un valore al motorino in proporzione a quello che avviene nel sensore.
Il sensore ci invia un dato che è compreso tra 90 e 10. Il motorino ha bisogno di un valore tra 0 e 180.
Il comando map esegue il rapporto tra i due valori. Es: valore = map(valore, 90, 10, 0, 179);
I primi due numeri si riferiscono al flex sensor mentre gli altri due al servo. In base al numero in entrata abbiamo un valore adatto al motorino.
Provate a caricare il codice qui sotto per capire meglio il funzionamento del comando MAP (oppure apri il file _2_1_sensore_1_motore_val)
#include
Servo myservo;
int indice;
void setup() {
Serial.begin(9600);
myservo.attach(9);
//Attacchiamo il servo al pin 9
}
void loop() {
indice = analogRead(A0);
Serial.print(“valore originale:”);
Serial.println(indice);
indice = map(indice, 90, 10, 0, 179);
myservo.write(indice);
Serial.print(“valore scalato:”);
Serial.println(indice);
//Stampiamo il valore originale del sensore e poi quello modificato dal comando map
delay(150);
}
Se pieghiamo il sensore il motorino si muove e tira il filo a cui è collegato il dito della mano robotica.
Iniziamo a realizzare il guanto e la mano robotica.
Prendiamo un guanto e attacchiamo il sensore sul dito indice. Il modo migliore per fissarlo è cucirlo o fissarlo con del nastro isolante.
Se possibile saldiamo dei lunghi cavi elettrici al sensore e colleghiamoli con Arduino.
Stiamo ancora realizzando un prototipo molto elementare, una volta capito il funzionamento e la quantità di cavi che dobbiamo utilizzare penseremo a montare il guanto definitivo.
Seguendo lo schema elettrico saldiamo cinque fili rossi ai pin positivi del sensore di flessione. Le estremità dei cavi rossi devono essere saldate insieme sul dorso della mano. Ai 5 fili ne aggiungiamo uno più lungo che colleghiamo al pin 5V di Arduino.
Prendiamo 5 piccoli fili neri e li saldiamo all’altra estremità del sensore di flessione. Per ogni cavo nero dobbiamo saldare una resistenza. All’altra estremità della resistenza saldiamo altri 5 fili neri che si uniscono al centro della mano. Da questi ultimi parte un ultimo filo nero più lungo che inseriamo nel Pin GND di Arduino.
A questo punto dobbiamo collegare 5 fili lunghi gialli. Ogni filo giallo deve essere saldato nella prima estremità della resistenza e deve essere collegato al pin analogico di Arduino. Ciascuno dei fili gialli finirà dunque nei pin A0, A1, A2, A3 e A4. Questi fili invieranno ad Arduino i dati di ciascun sensore di flessione.
Passiamo ora alla mano robotica.
Realizzare la mano è la parte più difficile dell’intero tutorial.
Segnalo questo tutorial (clicca qui) realizzato molto bene. Lo scopo è quello di creare una mano con le dita collegate a dei fili. Quando il motorino tira il filo, il dito si piega.
Se non volete costruire la mano robotica da soli potete acquistare questo giocattolo della 4M:
Robotic Hand Kit – www.amazon.com/4M-3774-Robotic-Hand-Kit/dp/B005MK0OPO
Una volta montata basta collegare i vari fili ai 5 motorini.
La realizzazione della mano la lascio alla vostra fantasia. Inviatemi via email (puccimarco76@yahoo.it) le vostre creazioni, le pubblicherò sul sito e sulla pagina
Facebook dei Tutorial di Arduino:
https://www.facebook.com/pages/Tutorial-Arduino/1377902315765530?fref=ts.
Qui sotto alcune immagini della mano robotica realizzata con una struttura di legno e le dita del giocattolo presentato qui sopra.
La struttura è la parte fondamentale della mano. I cinque motorini non devono muoversi (incollateli a dei tasselli di legno o fissateli con delle viti a delle barre di metallo).
Con del filo da pesca colleghiamo ogni motorino al dito costruito e assembliamo la parte elettronica dei 5 motorini.
ATTENZIONE: A seconda dei motorini scelti Arduino potrebbe non essere in grado di alimentarli tutti insieme. Acquistate un piccolo alimentatore esterno da 12V e collegate tutti i servo motore (i cavi rosso e nero dei motorini andranno all’alimentatore mentre il cavo arancione ad Arduino).
(Aprite lo sketc _4_tutti_sensori_tutti_motori_val)
Di seguito il codice completo per gestire i 5 sensori e i 5 motorini.
I valori da inserire nel comando MAP, es. map(pollice, 20, 40, 0, 179);
possono variare in base al vostro sensore, alla vostra resistenza, al tipo di motorini, ecc…
Vi consiglio di fare delle prove modificando i numeri fino a trovare il giusto compromesso tra movimento del guanto e risposta della mano robotica.
#include
Servo myservo_pollice;
Servo myservo_indice;
Servo myservo_medio;
Servo myservo_anulare;
Servo myservo_mignolo;
int pollice;
int indice;
int medio;
int anulare;
int mignolo;
void setup() {
Serial.begin(9600);
myservo_pollice.attach(9);
myservo_indice.attach(10);
myservo_medio.attach(11);
myservo_anulare.attach(12);
myservo_mignolo.attach(13);
}
void loop() {
pollice = analogRead(A0);
indice = analogRead(A1);
medio = analogRead(A2);
anulare = analogRead(A3);
mignolo = analogRead(A4);
Serial.println(mignolo);
pollice = map(pollice, 20, 40, 0, 179);
indice = map(indice, 20, 40, 0, 179);
medio = map(medio, 20, 40, 0, 179);
anulare = map(anulare, 20, 40, 0, 179);
mignolo = map(mignolo, 20, 40, 0, 179);
myservo_pollice.write(pollice);
myservo_indice.write(indice);
myservo_medio.write(medio);
myservo_anulare.write(anulare);
myservo_mignolo.write(mignolo);
delay(150);
}
Clicca qui per scaricare il file .zip con tutti gli sketch utilizzati per realizzare la mano robotica.
Ti è piaciuto il tutorial? Se ti va offrimi un caffè… [paypal-donation]
I tutorial sono liberamente scaricabili e condivisibili sotto l’etichetta Creative Commons (non è possibile commercializzarli e modificarli)
Scarica il Pdf del tutorial di Arduino “Robotic Hand”