Robot Tank con Arduino

Con questo progetto potrete realizzare il vostro Robot Tank con Arduino, che potrà via via essere accessoriato con sensori ed attuatori.

Iniziamo i lavori….

Iniziamo dal telaio e dai sensori di line-follower…

Prendere: 2 Sensori TCRT5000, 2 cavetti di 20 cm, 2 x M3x10, 2 x M3 Rondelle, 2 x M3 Dadi Esagonali:

Montiamo il telaio sul quale poi monteremo l’Arduino…

Occorreranno: 4 colonnette M3x10 in Plastica e 4 dadi M3 Esagonali sempre in Plastica:NOTA: Prestare attenzione al posizionamento delle colonnette altrimenti non sarà possibile montare successivamente la scheda. Monteremo ora i motori sui supporti motori…

Prendere i 2 Servo-Motori Continui (mod. SM-S4303R oppure i più veloci AR-3606HB), 2 Supporti Motori, 8 x M3x16, 8 x M3 Dadi Esagonali:

ATTENZIONE: Far coincidere la scanalatura del supporto motori con la vite di registro del servo.

Nota: Solitamente i Servo-Motori Continui sono tarati per stare fermi con la posizione 90 della libreria Servo di Arduino. Nel caso in cui alla posizione 90 i motori dovessero ruotare si deve agire DELICATAMENTE sul piccolo trimmer presente sul fianco del servo stesso fino ad arrestarli. Il trimmer serve quindi alla taratura della posizione di stop e non alla variazione della velocità!
Qui potrete scaricare lo sketch per testare i motori. Ora assembleremo insieme i due telai ed i supporti motori…

Saranno necessari: 8 x M3x12, 8 x M3 Dadi Esagonali:

Montaggio ingranaggio ruote folli…

Ne dovremmo assembleare 4! Per ogni ruota folle occorreranno: 2 gusci ingranaggio ruota folle, 4 x M3x10, 4 x M3 Dadi Esagonali, 1 cuscinetto 608ZZ.

Adesso monteremo gli assi delle ruote folli…

Per ogni ruota folle occorreranno: 1 x M8x45, 3 x M8 Rondelle, 3 x M8 Dadi Esagonali Autobloccanti, 1 supporto ruote folli:NOTA: Nella foto precedente i vari componenti sono in ordine di montaggio.

Sotto si vede come deve essere montato ogni asse.Adesso montiamo gli assi con le ruote folli al telaio…

Prendere: 2 assi ruote folli assemblati, il telaio con i motori, il supporto Batterie, il telaio supporto mini-servo, 8 x M3x25, 8 x M3 Dadi Esagonali:Attenzione: Fare attenzione alla posizione del telaio per il supporto mini-servo poiché non è simmetrico L’asse anteriore dovrà essere montato in battuta verso i motori e le viti non andranno strette troppo, dopo il montaggio dei cingoli ci servirà per regolarne la tensione…! Montiamo il mini-servo…

Prendere il mini-servo SG90 con le sue due viti di montaggio: Il cavo del mini-servo deve essere fatto passare nell’intercapedine tra il supporto ruote folli ed il telaio supporto mini-servo.Montaggio ingranaggi motore…

Prendere: 2 ingranaggi, 2 staffe a 6 punte del servo-motore e 12 viti M2x12:

Installazione degli ingranaggi motori sui motori:

Prendere: 2 ingranaggi pre-assemblati, 2 viti dei servo-motori: ATTENZIONE: Verificare che gli ingranaggi folli siano allineati a quello motore agendo sui dadi autobloccanti. Assemblaggio cingoli…

Per ogni cingolo occorreranno: 21 x M3x45, 21 M3 Dadi Esagonali Autobloccanti, 21 x Maglie Cingolo.

ATTENZIONE: Non serrare troppo i dadi, le singole maglie devono muoversi liberamente ed i due cingoli dovranno essere montati speculari, come nella foto sotto, Montare i cingoli sul Robot e regolare la tensione tramite l’asse anteriore.

Per poter evitare gli ostacoli si utilizzano i moduli ad ultrasuoni HC-SR04.ultrasonic_sensor_schema

Qui potrete scaricare lo sketch per testare il modulo ultrasuoni HC-SR04 (verificate i pin richiamati nello sketch prima di caricarlo nella scheda).

Occorreranno: 1 modulo HC-SR04, 1 cavetto da 10 cm, 1 x supporto ultrasuoni, 1 x blocco ultrasuoni, 2 x M3x14, 4 x M3 Rondelle, 2 x M3 Dadi Esagonali, 2 viti M2x8, 1 staffa a due braccia del mini-servo, 1 vite di fissaggio staffa del Mini-servo:

Montare il tutto come da foto sotto… Manca poco…

Eccome come risulta il nostro robot dopo aver fissato il sonar:Ed adesso sotto con le connessioni…..

Per questo robot abbiamo utilizzato un Arduino Nano con la shild di espansione, che ci permetterà di collegare tutto senza problemi.

Occorreranno: 4 x M3x8 Viti in Plastica:

Colleghiamo i componenti alla scheda…

Le connessioni possono essere fatte seguendo il seguente schema.

NOTA: Per semplificare lo schema non sono state riportate le connessioni a VCC e a GND dei vari componenti.

Finito…!

Ecco il nostro robot Tank dopo aver installato anche il modulo Bluetooth Come APP per Android vi consigliamo di usare la nostra  “Makerslab 1 Robot Control” scaricabile da qui
Uno Sketc di esempio da usare è il seguente:

// Firmware per robottino cingolato Nano
// Ultimo aggioramento 19/07/20
/******************************************************************
                             Librerie
 ******************************************************************/
#include <SoftwareSerial.h>
#include <Servo.h>
/******************************************************************
                Definizione dei pin e delle variabili
 ******************************************************************/
/* Definizione dei PIN usati sulla scheda */
#define SF_RX_PIN           2   /*  RX scheda arduinio da collegare al TX Bluetooth  */
#define SF_TX_PIN           3   /*  TX scheda arduinio da collegare al RX Bluetooth  */
#define trigPin             4   /* Pin Trig sensore ultrasuoni */
#define echoPin             5   /* Pin Echo sensore ultrasuoni */
#define sensIRDx            6   /*  Ir Destro */
#define sensIRSx            7   /*  Ir Sinistro */
#define pinminiservo        9   /*  Miniservo Utrasuoni */
#define pinruotaSinistra   10   /*  Sinistra servo Ruota */
#define pinruotaDestra     11   /*  Destra servo Ruota */

/* Definitione dei valori dei valori che possono assumere servo a rotazione continua, cioè le ruote */
#define ruotaStopValore 90
#define ruotaSinistraAvantiValore     0   // 180 per i servo AR-3606HB,   0 per i servo SM-S4303R
#define ruotaSinistraIndietroValore 180   //   0 per i servo AR-3606HB, 180 per i servo SM-S4303R
#define ruotaDestraAvantiValore     180   //   0 per i servo AR-3606HB, 180 per i servo SM-S4303R
#define ruotaDestraIndietroValore      0  // 180 per i servo AR-3606HB,   0 per i servo SM-S4303R

#define defaultDelay        10

SoftwareSerial bt =  SoftwareSerial(SF_RX_PIN, SF_TX_PIN);

int ritardo = 10;  // dichiaro la variabile Ritardo e preassegno un valore
int statodestroIR;   // dichiaro la variabile per salvare lo stato della lettura del sensore Ir Destro
int statosinistroIR; // dichiaro la variabile per salvare lo stato della lettura del sensore Ir Sinistro
int NERO = 1;     // 1 con sensori Ir TCRT5000
int BIANCO = 0;   // 0 con sensori Ir TCRT5000

/* Creazione oggetti per la libreria Servo */
Servo servoRadar;              /*  Valores from 0 to 180  */
Servo ruotaSinistra;           /*  Valores from 0 to 180  */
Servo ruotaDestra;             /*  Valores from 0 to 180  */

char dataBuffer;
int i = 0;
int numChar = 0;

long duration;
int cm;

#define MANUAL_CONTROL          0
#define LINE_FOLLOWER           1
#define LIGHT_FOLLOWER          2
#define EVITA_OSTACOLI          3
int currentState;

/******************************************************************
                       Definizione delle funzioni
 ******************************************************************/
void stopRuote() {
  ruotaSinistra.write(ruotaStopValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaStopValore);
  delay(defaultDelay);
}

void vaiAvanti() {
  ruotaSinistra.write(ruotaSinistraAvantiValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaDestraAvantiValore);
  delay(defaultDelay);
}

void vaiIndietro() {
  ruotaSinistra.write(ruotaSinistraIndietroValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaDestraIndietroValore);
  delay(defaultDelay);
}

void vaiAvantiSinistra() {
  ruotaSinistra.write(ruotaStopValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaDestraAvantiValore);
  delay(defaultDelay);
}

void vaiAvantiDestra() {
  ruotaSinistra.write(ruotaSinistraAvantiValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaStopValore);
  delay(defaultDelay);
}

void vaiIndietroSinistra() {
  ruotaSinistra.write(ruotaStopValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaDestraIndietroValore);
  delay(defaultDelay);
}

void vaiIndietroDestra() {
  ruotaSinistra.write(ruotaSinistraIndietroValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaStopValore);
  delay(defaultDelay);
}

void vaiRuotaSinistra() {
  ruotaSinistra.write(ruotaSinistraIndietroValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaDestraAvantiValore);
  delay(defaultDelay);
}

void vaiRuotaDestra() {
  ruotaSinistra.write(ruotaSinistraAvantiValore);
  delay(defaultDelay);
  ruotaDestra.write(ruotaDestraIndietroValore);
  delay(defaultDelay);
}

void lineFollower() {
  statosinistroIR = digitalRead(sensIRDx);
  statodestroIR = digitalRead(sensIRSx);

  if (statosinistroIR == NERO && statodestroIR == NERO) {
    vaiAvanti();
  }

  if (statosinistroIR == BIANCO && statodestroIR == NERO) {
    vaiAvantiDestra();
  }

  if (statosinistroIR == NERO && statodestroIR == BIANCO) {
    vaiAvantiSinistra();
  }

  if (statosinistroIR == BIANCO && statodestroIR == BIANCO) {
    stopRuote();
  }
}

void evitaOstacoli() {
  ultrasuoni();
  delay(100);
  if (cm < 18 ) { 
    vaiIndietro(); 
    delay(100);
  } 
  if (cm > 19 && cm < 30) { 
     vaiRuotaDestra(); 
     delay(500); 
  }  
  if (cm > 31) {
    vaiAvanti();
    delay(100);
  }
}

void ultrasuoni() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  cm = microsecondsToCentimeters(duration);
}
long microsecondsToCentimeters(long microseconds)
{
  return microseconds / 29 / 2;
}

void setup() {
  pinMode(SF_RX_PIN, INPUT);
  pinMode(SF_TX_PIN, OUTPUT);
  pinMode(sensIRSx, INPUT);
  pinMode(sensIRDx, INPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  bt.begin(9600);
  bt.flush();

  servoRadar.attach(pinminiservo);
  ruotaSinistra.attach(pinruotaSinistra);
  ruotaDestra.attach(pinruotaDestra);
}

void loop() {
  if (bt.available() > 0) {
    dataBuffer = bt.read();
    delay(3);
  }

  switch (dataBuffer) {
    case 'M':
      currentState = MANUAL_CONTROL;
      stopRuote();
      break;
    case 'I':
      currentState = LINE_FOLLOWER;
      break;
    case 'G':
      currentState = LIGHT_FOLLOWER;
      break;
    case 'B':
      currentState = EVITA_OSTACOLI;
      break;
    case 'A':
      vaiAvantiSinistra();
      break;
    case 'U':
      vaiAvanti();
      break;
    case 'F':
      vaiAvantiDestra();
      break;
    case 'L':
      vaiRuotaSinistra();
      break;
    case 'R':
      vaiRuotaDestra();
      break;
    case 'C':
      vaiIndietroSinistra();
      break;
    case 'D':
      vaiIndietro();
      break;
    case 'E':
      vaiIndietroDestra();
      break;
  }

  bt.flush();
  if (currentState == LINE_FOLLOWER) {
    lineFollower();
  } else if (currentState == LIGHT_FOLLOWER) {
    //avoidTheLight();
  } else if (currentState == EVITA_OSTACOLI) {
    evitaOstacoli();
  }
}

NOTE: Questo progetto trae spunto dai seguenti progetti:
https://www.thingiverse.com/thing:14599
https://www.thingiverse.com/thing:284242