#MAKE
14/03/14
Un robot omnidirezionale fatto con i LEGO Mindstroms e che usa tre delle nostre ruote
Questo robot è stato fatto per dimostrare come le nostre ruote omnidirezionali siano ottime anche per i robot fatti con i Lego Mindstorms. La struttura è molto semplice: ci sono tre motori, ognuno ruotato di 120° rispetto agli altri e e collegati al controllore NXT 2.0. Non ci sono sensori, perché, come già detto, lo scopo è dimostrare il funzionamento delle nostre ruote, senza nessun altro scopo. (Ringraziamo i ragazzi di "The Urban Reef" per averci prestato il materiale essenziale per sviluppare questo robot)
Facendo riferimento alla nostra guida su come utilizzare i nostri modelli di ruote omnidirezionali, proviamo a immaginare quali sono le combinazioni che servono per fare i movimenti basilari. Considerando che i motori sono tutti collegati con la stessa polarità, numeriamo per comodità i motori partendo da quello in alto a destra e procedendo in senso orario. Notiamo che ci sono due tipi di movimenti: quelli lungo una traiettoria coincidente con un asse di un motore e quelli lungo una traiettoria perpendicolare con un asse di un motore.
Un esempio di movimento coincidente ad un asse di un motore è lo spostamento in avanti dritto; per questo tipo di movimento il motore che ha l'asse coincidente con la traiettoria sta fermo, mentre gli altri due girano in senso opposto l'uno dall'altro e con uguale velocità (la direzione di rotazione dipende dal verso in cui si vuole andare rispetto a tale traiettoria, l'importante è che i due motori girino in senso opposto). In particolare, per andare avanti dritto vediamo che il motore 2 deve stare fermo, mentre il motore 1 va in avanti e il motore 3 va all'indietro.
Un esempio di movimento perpendicolare ad un asse di un motore, invece, è lo spostamento a destra; per questo tipo di movimento il motore che ha l'asse perpendicolare con la traiettoria gira nel verso che coincide con la direzione del movimento desiderato, mentre gli altri due girano in senso opposto a quello dell'altro motore e con una velocità dimezzata. In particolare, per andare dritto a destra vediamo che il motore 2 deve andare in avanti, mentre i motori 1 e 3 vanno all'indietro con velocità dimezzata rispetto a quella del motore 2.
Gli altri movimenti rettilinei sono molto simili a quelli appena descritti e non ci dilunghiamo nella loro spiegazione, passiamo a vedere i movimenti rotatori, invece. Questi sono molto semplici: se si vuole far ruotare il robot in senso orario tutti i motori devono ruotare all'indietro; al contrario, per ruotare in senso antiorario tutti i motori devono ruotare in avanti.
Dunque abbiamo visto quanto semplice sia gestire un robot che monti le nostre ruote omnidirezionali e come basti un po' di ragionamento per riuscire a muoverlo in ogni direzione.
In questa discussione si evidenzia che ogni motore deve essere gestito individualmente, dunque la prossima domanda a cui rispondere è: come gestire questi tre motori?
Di seguito descriveremo la parte di codice utilizzata per gestire i 14 movimenti basilari, più precisamente la funzione che viene usata per gestire tali movimenti.
/*
La variabile speed può assumere valori da 0 a 127 e va a regolare
la velocità di rotazione di tutti i motori.
La variabile direction può assumere i seguenti valori:
- 0 per far star fermo il robot;
- 1 per far muovere il robot in avanti rispetto all'asse 0;
- 2 per far muovere il robot in avanti rispetto all'asse a 30°;
- 3 per far muovere il robot in avanti rispetto all'asse a 60°;
- 4 per far muovere il robot in avanti rispetto all'asse a 90°;
- 5 per far muovere il robot in avanti rispetto all'asse a 120°;
- 6 per far muovere il robot in avanti rispetto all'asse a 150°;
- 7 per far muovere il robot indietro rispetto all'asse 0;
- 8 per far muovere il robot indietro rispetto all'asse a 30°;
- 9 per far muovere il robot indietro rispetto all'asse a 60°;
- 10 per far muovere il robot indietro rispetto all'asse a 90°;
- 11 per far muovere il robot indietro rispetto all'asse a 120°;
- 12 per far muovere il robot indietro rispetto all'asse a 150°;
- 13 per fare ruotare il robot su se stesso in senso orario;
- 14 per fare ruotare il robot su se stesso in senso antiorario.
*/
void Move(byte direction, byte speed)
{
// Controlla che il valore di speed richiesto non sia sopra il limite
speed=speed>127?127:speed;
char m1,m2,m3;
// Sceglie quale movimento fare in base al valore di direction inserito
switch(direction){
// Direzione 1
case 1:{
m1=speed; // Motore 1 gira in avanti
m2=0; // Motore 2 fermo
m3=-speed; // Motore 3 gira all'indietro
}
break;
// Direzione 2
case 2:{
m1=speed/2; // Motore 1 gira in avanti a velocità dimezzata
m2=speed/2; // Motore 2 gira in avanti a velocità dimezzata
m3=-speed; // Motore 3 gira all'indietro
}
break;
// Direzione 3
case 3:{
m1=0; // Motore 1 fermo
m2=speed; // Motore 2 gira in avanti
m3=-speed; // Motore 3 gira all'indietro
}
break;
// Direzione 4
case 4:{
m1=-speed/2; // Motore 1 gira all'indietro a velocità dimezzata
m2=speed; // Motore 2 gira in avanti
m3=-speed/2; // Motore 3 gira all'indietro a velocità dimezzata
}
break;
// Direzione 5
case 5:{
m1=-speed; // Motore 1 gira all'indietro
m2=speed; // Motore 2 gira in avanti
m3=0; // Motore 3 fermo
}
break;
// Direzione 6
case 6:{
m1=speed; // Motore 1 gira in avanti
m2=0; // Motore 2 fermo
m3=-speed; // Motore 3 gira all'indietro
}
break;
// Direzione 7
case 7:{
m1=-speed; // Motore 1 gira all'indietro
m2=0; // Motore 2 fermo
m3=speed; // Motore 3 gira in avanti
}
break;
// Direzione 8
case 8:{
m1=-speed/2; // Motore 1 gira all'indietro a velocità dimezzata
m2=-speed/2; // Motore 2 gira all'indietro a velocità dimezzata
m3=speed; // Motore 3 gira in avanti
}
break;
// Direzione 9
case 9:{
m1=0; // Motore 1 fermo
m2=-speed; // Motore 2 gira all'indietro
m3=speed; // Motore 3 gira in avanti
}
break;
// Direzione 10
case 10:{
m1=speed/2; // Motore 1 gira in avanti a velocità dimezzata
m2=-speed; // Motore 2 gira all'indietro
m3=speed/2; // Motore 3 gira in avanti a velocità dimezzata
}
break;
// Direzione 11
case 11:{
m1=speed; // Motore 1 gira in avanti
m2=-speed; // Motore 2 gira all'indietro
m3=0; // Motore 3 fermo
}
break;
// Direzione 12
case 12:{
m1=-speed; // Motore 1 gira all'indietro
m2=0; // Motore 2 fermo
m3=speed; // Motore 3 gira in avanti
}
break;
// Direzione 13
case 13:{
m1=-speed; // Motore 1 gira all'indietro
m2=-speed; // Motore 2 gira all'indietro
m3=-speed; // Motore 3 gira all'indietro
}
break;
// Direzione 14
case 14:{
m1=speed; // Motore 1 gira in avanti
m2=speed; // Motore 2 gira in avanti
m3=speed; // Motore 3 gira in avanti
}
break;
// Tutti i motori fermi
case 0:
default:{
m1=0;
m2=0;
m3=0;
}
break;
}
// Aggiorno le velocità dei motori
OnFwd(OUT_A, m1);
OnFwd(OUT_B, m2);
OnFwd(OUT_C, m3);
}
In questo video mostriamo i movimenti che riesce a fare il robot grazie alle nostre ruote omnidirezionali. In questo caso, per comodità, lo stavamo controllando via bluetooth tramite un'app per Android.
Al momento non abbiamo un uffico,
ma siamo spesso tra Padova e Vicenza.
Se avete bisogno di incontrarci,
contattateci e ci organizzeremo.
Di solito rispondiamo rapidamente, se non ricevete
alcuna risposta basta che mi rimandiate l'email
o che proviate un altro metodo.
Info@VicenzaThunders.com
Attenzione: se avete bisogno di chiamarci, vi
suggeriamo di spedirci un'email o un SMS prima
perché non siamo sempre disponibili.
Potete anche utilizzare WhatsApp se volete.
+393484808073
+393494548359
Potete trovarci su molti social network,
quando abbiamo tempo ci piace condividere
i nostri lavori e le nostre esperienze!