ultimo aggiornamento 30 novembre 2014

JLCPCB - 2$ per prototipi di PCB, di qualsiasi colore. Produzione in 24 ore!
L'Azienda di prototipi PCB più popolare, con oltre 700.000 clienti in tutto il mondo!
Continua la produzione dei PCB standard a 2 strati durante le festività primaverili


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.

homotix

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