Per il controllo del robot occorrono due programmi: uno per la
stazione di controllo e uno
per
il robot.
Il primo permette l’interfacciamento del controller, che secondo il tasto
premuto invia tramite il modulo Xbee un carattere verso il robot.
Il secondo programma converte il carattere ricevuto in comandi che andranno ad
attivare i motori del robot oppure i servi per muovere il dispositivo pan & tilt
su cui è montata la telecamera.
I programmi dovranno
essere trasferiti sulla memoria del processore della scheda Arduino tramite
l’apposito programma IDE.
Attenzione: i programmi sono stati testati
solamente sulla versione dell'IDE versione 0023, questa può ancora essere
scaricata dal sito Arduino.
Per il funzionamento occorre sia anche scaricata l'apposita
libreria per la gestione del Controller.
NOTA: Per caricare i programmi è preferibile che sulle schede Arduino, non siano
montati gli Shield poiché i moduli Xbee comunicano con Arduino utilizzando i pin
0 e 1 (TX e RX) che sono gli stessi utilizzati per la programmazione, che per
interferenze potrebbe non essere portata a compimento e dare errore.
Schema del robot ArduinoBOT
Pin scheda Arduino Utilizzati
|
Pin scheda Arduino |
Funzione nel robot ArduinoBOT |
|
Pin +5V |
+5V |
|
Pin GND |
GND |
|
Pin Vin |
+6V Batteria |
|
Pin digitale 0 |
RX XBee |
|
Pin digitale 1 |
TX Xbee |
|
Pin digitale 3 |
PWM pin 3 servo TILT (alto-basso)
|
|
Pin Digitale 6 |
PWM pin 10 servo PAN (destra-sinistra)
|
|
Pin Digitale 13 |
Direzione Motore DX (DIR B) |
|
Pin Digitale 12 |
Direzione Motore SX (DIR A) |
|
Pin Digitale 11 |
Attivazione Motore DX (SP B) |
|
Pin Digitale 10 |
Attivazione Motore DX (SP A) |
|
Programma per la stazione di controllo
Il programma riportato nel Listato utilizza per il
suo funzionamento due librerie una chiamata psx.h e una chiamata Wprogram.h
(oppure Arduino.h se utilizza il programma Arduino ). Assicurarsi che queste
siano presenti nella cartella delle librerie del programma.
Nella tabella sono riportate le funzioni dei tasti e quale carattere viene
inviato verso il robot.
Tabella tasti di comando del robot
|
Tasto controller |
Carattere inviato |
Funzione |
|
Tasto direzione SU |
W |
Il robot si muove in avanti |
|
Tasto direzione GIU’ |
S |
Il robot arretra |
|
Tasto direzione SINISTRA |
A |
Il robot ruota a sinistra |
|
Tasto direzione DESTRA |
D |
Il robot ruota a destra |
|
Tasto L1 |
X |
Il robot si ferma |
|
Tasto TRIANGOLO |
T |
La telecamera si muove verso il basso
|
|
Tasto X |
G |
La telecamera si muove verso l’alto
|
|
Tasto QUADRATO |
F |
La telecamera ruota a sinistra |
|
Tasto CERCHIO |
H |
La telecamera ruota a destra |
|
Tasto R1 |
B |
La telecamera si porta in posizione neutra
|
|
Listato programma stazione di controllo
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <Psx.h> // Includes the Psx Library
#define dataPin 2
#define cmndPin 3
#define attPin 4
#define clockPin 5
Psx Psx; // Initializes the library
unsigned int data = 0; // data stores the controller response
void setup()
{
Psx.setupPins(dataPin, cmndPin, attPin, clockPin, 10); // Defines what each pin is used
// (Data Pin #, Cmnd Pin #, Att Pin #, Clk Pin #, Delay)
// Delay measures how long the clock remains at each state,
// measured in microseconds.
Serial.begin(9600);
}
void loop()
{
data = Psx.read(); // Psx.read() initiates the PSX controller and returns the button data
if (data & psxLeft){
Serial.print ("a");
}
if (data & psxDown){
Serial.print ("s");
}
if (data & psxRight){
Serial.print ("d");
}
if (data & psxUp){
Serial.print ("w");
}
if (data & psxSqu){
Serial.print ("f");
}
if (data & psxX){
Serial.print ("g");
}
if (data & psxO){
Serial.print ("h");
}
if (data & psxTri){
Serial.print ("t");
}
if (data & psxR1){
Serial.print ("b");
}
if (data & psxL1){
Serial.print ("x");
}
delay (500);
} |
|
Programma per il robot ArduinoBOT
Il programma riportato nel listato utilizza la
libreria servo.h: per l’azionamento dei servo, per questo motivo la velocità dei motori è fissa in quanto l’utilizzo della
Liberia servo.h e in particolare la funzione servo.attach() inibisce la funzione PWM sui pin 9 e 10.
Il pin 10 è utilizzato dalla scheda motore per l’abilitazione di uno dei motori,
tale pin non può essere riconfigurato. Nel programma sono presenti alcune
variabili che possono essere modificate per adattarsi al proprio montaggio,
queste sono riportate nella Tabella sotto riportata.
Variabili di impostazione del dispositivo Pan & Tilt
|
Pan_neutro |
Posizione iniziale del servo Pan
|
|
Tilt_neutro |
Posizione iniziale del servo Tilt
|
|
AngoloPan |
Posizione iniziale del servo |
|
Angolo Tilt |
Posizione iniziale del servo |
|
DeltaPan |
Gradi per il movimento del servo Pan
|
|
DeltaTilt |
Gradi per il movimento del servo Tilt
|
|
Listato programma per il robot ArduinoBOT
#include <Servo.h> // Libreria per controllo servomotori
Servo PanServo; // Creazione dell'oggetto PanServo
Servo TiltServo; // Creazione dell'oggetto TiltServo
int tilt = 3; // Pin a cui è collegato il servo Tilt
int pan = 6; // Pin a cui è collegato il servo Pan
int E1 = 11; // Pin per abilitazione Motore DX
int E2 = 10; // Abilita Motore SX
int M1 = 13; // Direzione Motore DX
int M2 = 12; // Direzione Motore SX
int Pan_neutro = 40; // Posizione iniziale del servo Pan
int Tilt_neutro = 60; // Posizione iniziale del servo Tilt
int AngoloPan = Pan_neutro; // Posizione iniziale del servo Pan
int AngoloTilt = Tilt_neutro; // Posizione iniziale del servo Tilt
byte DeltaPan = 3; // movimento di 3 gradi
byte DeltaTilt = 3; // movimento di 3 gradi
void setup(void)
{
Serial.begin(9600); //imposta la porta di comunicazione con L'XBee
pinMode(E1, OUTPUT); // Imposta il pin come uscita
pinMode(E2, OUTPUT);
pinMode(M1, OUTPUT);
pinMode(M2, OUTPUT);
PanServo.attach(pan); // Collega al pin relativo l'oggetto PanServo
TiltServo.attach(tilt); // Collega al pin relativo l'oggetto TiltServo
PanServo.write(AngoloPan); //Invia al PanServo gli impulsi necessari a portarlo all'angolo indicato
TiltServo.write(AngoloTilt);//Invia al TiltServo gli impulsi necessari a portarlo all'angolo indicato
}
void loop(void)
{
while (Serial.available() < 1) {
} // Attesa sino a quando riceve un carattere
char val = Serial.read(); // Legge il carattere dal modulo XBee e lo salva nella variabile val
switch(val) // Eseguie i comandi in base al carattere ricevuto
{
case 'w':// Se il carattere ricevuto è 'w' esegue la routine Robot avanti
robot_avanti ();
break;
case 's'://Se il carattere ricevuto è 's' esegue la routine Robot indietro
robot_indietro ();
break;
case 'a'://Se il carattere ricevuto è 'a' esegue la routine Robot sinistra
robot_sinistra ();
break;
case 'd'://Se il carattere ricevuto è 'd' esegue la routine Robot destra
robot_destra ();
break;
case 'x'://Se il carattere ricevuto è 'a' esegue la routine Robot fermo
stop();
break;
case 'f'://Se il carattere ricevuto è 'f' ruota a destra il servo Pan
AngoloPan += DeltaPan;
pan_tilt();
break;
case 'h'://Se il carattere ricevuto è 'h' ruota a sinistra il servo Pan
AngoloPan -= DeltaPan;
pan_tilt();
break;
case 'g'://Se il carattere ricevuto è 'g' ruota in avanti il servo Tilt
AngoloTilt += DeltaTilt;
pan_tilt();
break;
case 't'://Se il carattere ricevuto è 't' ruota in indietro il servo Tilt
AngoloTilt -= DeltaTilt;
pan_tilt();
break;
case 'b'://Se il carattere ricevuto è 'b' centra la telecamera
{
AngoloPan=Pan_neutro;
AngoloTilt=Tilt_neutro;
pan_tilt();
break;
};
default:
stop(); // Ferma il robot
break;
}
}
void stop(void) //Robot fermo
{
digitalWrite(E1,LOW); //Disabilita il comando del motore
digitalWrite(E2,LOW);
}
void robot_indietro()
{
digitalWrite(E1,HIGH);
digitalWrite(M1,LOW);
digitalWrite(E2,HIGH);
digitalWrite(M2,LOW);
}
void robot_avanti ()
{
digitalWrite(E1,HIGH);
digitalWrite(M1,HIGH);
digitalWrite(E2,HIGH);
digitalWrite(M2,HIGH);
}
void robot_sinistra ()
{
digitalWrite(E1,HIGH);
digitalWrite(M1,HIGH);
digitalWrite(M2,HIGH);
digitalWrite(M2,LOW);
}
void robot_destra ()
{
digitalWrite(E1,HIGH);
digitalWrite(M1,LOW);
digitalWrite(M2,HIGH);
digitalWrite(M2,HIGH);
}
void pan_tilt()
{
// Controlla i limiti per il movimento Pan
AngoloPan=(AngoloPan < 20)?20:AngoloPan;
AngoloPan=(AngoloPan > 80)?80:AngoloPan;
// Controlla i limiti per il movimento Tilt
AngoloTilt=(AngoloTilt < 60)?60:AngoloTilt;
AngoloTilt=(AngoloTilt > 100)?100:AngoloTilt;
// Invia ai servo i comandi necessari
PanServo.write(AngoloPan);
TiltServo.write(AngoloTilt);
} |
|
|
Elenco revisioni |
| 30/11/2013 |
Emissione preliminare |
Private Policy
Cookie Policy
