Robot Beginner Kit variante di Anto 2

Il robot beginner kit è nato per essere il tuo primo robot e per avvicinarti ai primi concetti di robotica terrestre.

beginner kit

Un appassionato di robotica e makers come Anto, già autore di una variante del Robot Beginner Kit, ha colto in pieno l’uso del beginner kit e continua a far evolvere il suo robot.

Anto mi ha inviato le foto di una interessante evoluzione perchè potessi condividerle attraverso il Blog con te e tutti gli appassionati di robotica e di arduino.

La seconda variante del Beginner Kit

L’evoluzione che Anto ha realizzato prevede una translazione della base superiore rispetto a quella inferiore che ha subito 2 vantaggi:

  1. far spazio per un pacco batterie di maggiore capienza;
  2. darti la possibilità di montare una ruota anteriore snodata.

A quella che sembra solo una evoluzione meccanica segue l’evoluzione elettronica: il nuovo robot beginner kit è dotato di 3 led, un pulsante ed un nuovo transistor NPN che amplifica il suono emesso dal cicalino.

Ecco i collegamenti elettrici del beginner kit:

beginner kit collegamenti

Evoluzione meccanica

meccanicamente Anto ha realizzato alcune foto del suo robot per mostrarti il montaggio da tutti i suoi lati, destro:

robot beginner kit

in cui vedi come le due basi siano state traslate l’una rispetto all’altra, una migliore visione la puoi avere anche dal lato sinistro:

beginner kit sinistra

il sensore sharp è posto sul davanti al centro in modo fisso e lo vedi bene dalla foto frontale:

beginner kit fronte

mentre il retro ti mostra lo spazio ricavato per ospitare un pacco batterie capiente e potente:

beginner kit retro

ed infine una foto dall’alto in cui puoi vedere come sono assemblati i componenti del robot:

beginner kit alto

Lo sketch del Robot Beginner Kit

Anto ha voluto condividere anche lo sketch che controlla il suo beginner kit:

//Robot multifunzione:
//Programma:
//0. Fermo
//1. Movimento evitando ostacoli
//2. Movimento seguendo oggetto posto di fronte al sensore 
//3. Piano virtuale: mettendo la mano di fronte al sensore a varie distanze si generano diverse note
//4. Balletto: il robot balla sulle note di "Fra Martino campanaro"
//5. ..... 

#include <Servo.h>

#define PWMA 3
#define PWMB 5
#define AIN1 4
#define AIN2 7
#define BIN1 8
#define BIN2 12
#define STBY 2
#define motoreA 0
#define motoreB 0
#define AVANTI 0
#define INDIETRO 0
#define SENSIBILITA 100 //valore orig 300
#define pinTesta 11

int speakerOut = A4;
// definizione delle note 
#define  c     3830    // 261 Hz 
#define  d     3400    // 294 Hz 
#define  e     3038    // 329 Hz 
#define  f     2864    // 349 Hz 
#define  gg     2550    // 392 Hz gg e non g per non entrare in conflitto con altra variabile
#define  a     2272    // 440 Hz 
#define  b     2028    // 493 Hz 
#define  C     1912    // 523 Hz 
#define  R     0

int SHIR = A5;
int ledPin1=9;
int ledPin2=10;
int ledPin3=13;
int inPin=6;
int val=0;
int direzione=0;
int programma= 0;

Servo testa;

void setup() //setup pin
{
   pinMode( STBY,OUTPUT );
   pinMode( PWMA,OUTPUT );
   pinMode( PWMB,OUTPUT );
   pinMode( AIN1,OUTPUT );
   pinMode( AIN2,OUTPUT );
   pinMode( BIN1,OUTPUT );
   pinMode( BIN2,OUTPUT );
   pinMode( SHIR,INPUT );//sensore ir su pin A5
   pinMode(ledPin1, OUTPUT);//led pin 9
   pinMode(ledPin2, OUTPUT);//led pin 10
   pinMode(ledPin3, OUTPUT);//led pin 13
   pinMode(inPin, INPUT);//pulsante pin 6
   pinMode(speakerOut, OUTPUT);//buzzer su pin A4
   digitalWrite( STBY,HIGH );
   testa.attach(pinTesta);
   testa.write(90);
}

long tempo = 10000;
int pause = 1000;
int rest_count = 100; 
int tone_ = 0;
int beat = 0;
long duration  = 0;
int nota = 0;

void loop() //routine principale
{
   controllo();//verifica pressione pulsante

   if (programma == 0) //fermo led accesi 000
   {
       digitalWrite( ledPin1,LOW );
       digitalWrite( ledPin2,LOW  );
       digitalWrite( ledPin3,LOW );
       analogWrite( PWMA,50 );
       analogWrite( PWMB,50 );
       digitalWrite( AIN1,LOW );
       digitalWrite( AIN2,LOW );
       digitalWrite( BIN1,LOW );
       digitalWrite( BIN2,LOW );
       digitalWrite( STBY,LOW );
    }

    if (programma == 1) //evita ostacoli led accesi 100
    {
       digitalWrite( ledPin1,HIGH );
       digitalWrite( ledPin2,LOW  );
       digitalWrite( ledPin3,LOW );
       digitalWrite( STBY,HIGH );
       prog1();
   }

   if (programma == 2) //segue oggetto led accesi 110
   {
       digitalWrite( ledPin1,HIGH );
       digitalWrite( ledPin2,HIGH  );
       digitalWrite( ledPin3,LOW );
       digitalWrite( STBY,HIGH );
       prog2();
   }

   if (programma == 3) // piano virtuale led accesi 111
   {
       digitalWrite( ledPin1,HIGH );
       digitalWrite( ledPin2,HIGH  );
       digitalWrite( ledPin3,HIGH );
       analogWrite( PWMA,50 );
       analogWrite( PWMB,50 );
       digitalWrite( AIN1,LOW );
       digitalWrite( AIN2,LOW );
       digitalWrite( BIN1,LOW );
       digitalWrite( BIN2,LOW );
       digitalWrite( STBY,LOW );
       prog3();
   }

   if (programma == 4) // il robot balla sulle note di "fra Martino campanaro" led accesi 101
   {
       digitalWrite( ledPin1,HIGH );
       digitalWrite( ledPin2,LOW  );
       digitalWrite( ledPin3,HIGH );
       digitalWrite( STBY,HIGH );
       prog4();
   }

   if (programma == 5) //....libero per aggiunta eventuale funzione......
   {
       digitalWrite( ledPin1,LOW );
       digitalWrite( ledPin2,HIGH  );
       digitalWrite( ledPin3,HIGH );
       analogWrite( PWMA,50 );
       analogWrite( PWMB,50 );
       digitalWrite( AIN1,LOW );
       digitalWrite( AIN2,LOW );
       digitalWrite( BIN1,LOW );
       digitalWrite( BIN2,LOW );
       digitalWrite( STBY,LOW );
   }
}

void avanti() //avanti
{
   digitalWrite( AIN1,HIGH );
   digitalWrite( AIN2,LOW );
   digitalWrite( BIN1,LOW );
   digitalWrite( BIN2,HIGH );
   analogWrite( PWMA,100 );
   analogWrite( PWMB,100 );
   testa.write(90);
}

void indietro() //indietro
{
   digitalWrite( AIN1,LOW );
   digitalWrite( AIN2,HIGH );
   digitalWrite( BIN1,HIGH );
   digitalWrite( BIN2,LOW );
   analogWrite( PWMA,100 );
   analogWrite( PWMB,100 );
   testa.write(90);
}

void alt() //frena
{
   analogWrite( PWMA,50 );
   analogWrite( PWMB,50 );
   digitalWrite( AIN1,LOW ); 
   digitalWrite( AIN2,LOW );
   digitalWrite( BIN1,LOW );
   digitalWrite( BIN2,LOW );
}

void giraD() //gira a destra
{
   digitalWrite( AIN1,HIGH ); 
   digitalWrite( AIN2,LOW );
   digitalWrite( BIN1,LOW );
   digitalWrite( BIN2,HIGH );
   analogWrite( PWMA,70 );
   analogWrite( PWMB,100 );
   testa.write(50);
}

void giraS() // gira a sinistra
{
   digitalWrite( AIN1,HIGH );
   digitalWrite( AIN2,LOW );
   digitalWrite( BIN1,LOW );
   digitalWrite( BIN2,HIGH );
   analogWrite( PWMA,100 );
   analogWrite( PWMB,70 );
   testa.write(130);
}

void indiS() //indietro a sinistra
{
   digitalWrite( AIN1,LOW );
   digitalWrite( AIN2,HIGH );
   digitalWrite( BIN1,HIGH );
   digitalWrite( BIN2,LOW );
   analogWrite( PWMA,100 );
   analogWrite( PWMB,70 );
   testa.write(130);
}

void indiD() //indietro a destra
{
   digitalWrite( AIN1,LOW );
   digitalWrite( AIN2,HIGH );
   digitalWrite( BIN1,HIGH );
   digitalWrite( BIN2,LOW );
   analogWrite( PWMA,70 );
   analogWrite( PWMB,100 );
   testa.write(50);
}

void playTone() { // routine creazione suono
   long elapsed_time = 0;
   if (tone_ > 0) {  
      while (elapsed_time < duration) {
      digitalWrite(speakerOut,HIGH);
      delayMicroseconds(tone_ / 2);
      digitalWrite(speakerOut, LOW);
      delayMicroseconds(tone_ / 2);
      elapsed_time += (tone_);
     } 
  } else { // Rest beat; loop times delay
      for (int j = 0; j < rest_count; j++) { // See NOTE on rest_count
         if (digitalRead(inPin)==LOW) { return; }
            delayMicroseconds(duration);  
      }                                
  }                                 
}

void controllo() //controlla pressione pulsante e se sì passa al programma successivo
{
   val = digitalRead(inPin);
   if (val == LOW) {
      programma = programma + 1; 
      if (programma==6) //programmi massimo 5 (volendo si può aumentare) se la variabile va a 6 viene reimpostata a 0 
     {
         programma = 0; 
     } 
  } 
  delay(300);  
}

void prog1() // evita ostacoli
{
   int dist = analogRead(SHIR);
   if ( dist > SENSIBILITA ) {
      alt();
      giraS(); 
      delay( 600 );
      int dist = analogRead(SHIR);
      if ( dist > SENSIBILITA + 50 ) {
         alt();
         indiS(); 
         delay( 600 );
         alt();
         giraD();
         delay( 600 );
         if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante 
         int dist = analogRead(SHIR);
         if ( dist > SENSIBILITA + 50 ) {
            alt();
            indiD(); 
            delay( 600 );
            alt();
            indietro();
            if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante 
            delay( 1000 );
            alt();
            giraS(); 
            delay( 600 );
         }
      }
   } else {
      avanti();
   }
}

void prog2() //segue oggetto
{
int dist = analogRead(SHIR);
if ( dist > SENSIBILITA ) 
{
  avanti();
}
else
{
    alt();
    giraS(); 
    delay( 600 );

    int dist = analogRead(SHIR);
    if ( dist < SENSIBILITA + 50 ) {
       alt();
       indiS(); 
       delay( 600 );
       alt();
       giraD();
       delay( 600 );
       if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante 
       int dist = analogRead(SHIR);
       if ( dist < SENSIBILITA + 50 ) {
          alt();
          indiD(); 
          delay( 600 );
          if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante 
          alt();
          indietro();
          delay( 1000 );
          if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante 
          alt();
          giraS(); 
          delay( 600 );
       }
    }
 }
}

void prog3() //piano virtuale
{
   int dist = analogRead(A5);

   tone_ = dist*10;
   duration = 16000;
   playTone(); 

}

void prog4() //balletto
{
   int melody[]  = {c,d,e,c,c,d,e,c,e,f,gg,e,f,gg,gg,a,gg,f,e,c,gg,a,gg,f,e,c,c,gg,c,c,gg,c}; //array con le note della canzone
   for ( int g=0; g<32; g++) { 
      direzione = direzione +1;  //un passo avanti e uno indietro
      if (direzione==7) { direzione=1; }
      if (direzione==1) { alt(); avanti(); }
      if (direzione==2) { alt(); indietro(); }
      if (direzione==3) { alt(); giraS(); }
      if (direzione==4) { alt(); indiS(); }
      if (direzione==5) { alt(); giraD(); }
      if (direzione==6) { alt(); indiD(); }
      tone_ = melody[g]; 
      duration = 1600000;
      playTone(); //suona la nota
      if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante 
   }
}

Buon divertimento !!!

Cortesemente, prima di inserire i commenti leggi il regolamento

Permanent link to this article: http://www.mauroalfieri.it/elettronica/robot-beginner-kit-variante-anto-2.html

1 comment

    • Federico on 1 maggio 2014 at 20:28
    • Reply

    Interessante, davvero soprattutto per la struttura del robot, davvero bilanciata e funzionale. Unico possibile problema : il robot non dovrebbe andare dritto necessita di compensazione tra i due motorini.
    Utile il servo utilizzato come ruota per far sterzare il robot. Bravo !

Lascia un commento

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.