Robot Beginner Kit – variante di Anto

L’articolo di oggi è dedicato ad Anto che ha realizzato il Robot Beginner Kit seguendo i miei articoli ed ha fatto evolvere il progetto.

Robot Beginner Kit

Anto mi ha scritto:

Ciao, grazie alle tue istruzioni sono riuscito a costruire il beginner robot. Ho aggiunto però un alimentatore esterno perchè col pacco pile non aveva abbastanza potenza. Aggiunti poi dei led, un buzzer per dare voce al robottino, e un pulsante per avere la possibilità di fare girare diverse procedure senza il bisogno di dover di volta in volta uploadare i diversi programmi. Premendolo in qualsiasi momento si può cambiare la funzione che il robot deve eseguire. Ti mando il listato se può servire a qualcuno e mi scuso se ho spudoratamente copiato-incollato il tuo sketch e per le varie inesattezze che avro’ commesso ma non sono proprio del settore.

Innanzitutto GRAZIE Anto sia perchè hai realizzato una variante del Robot Beginner Kit sia per averla inviata con il desiderio di condividerla con tutti gli appassionati; in secondo luogo grazie per i complimenti ne arrivano tanti e mi fanno sempre piacere, mi stimolano a continuare in questa passione ( Arduino ) e a manutenere il Blog sempre aggiornato.

Purtroppo Anto non mi ha inviato lo schema delle connessioni dei componenti aggiuntivi, quindi parti dallo sketch e poi vediamo un metodo per capire che connessioni fare.

Lo sketch del Robot Beginner Kit di Anto

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

#include

#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 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 grad[] = {90,0,180};
int distanza = 0;
int direzione = 0;
int ledPin1=9;
int ledPin2=10;
int ledPin3=13;
int inPin=6;
int val=0;
int programma= 0;
Servo testa;

//setup pin************************************************************
void setup()
{
   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;

//routine principale*************************************************
void loop()
{
   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 );
}

}

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

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

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

//gira a destra*************************************************
void giraD()
{
      alt();
      delay( 500 );
      indietro();
      delay( 500 );
      alt();
      delay( 500 );
      digitalWrite( AIN1,HIGH );
      digitalWrite( AIN2,LOW );
      digitalWrite( BIN1,LOW );
      digitalWrite( BIN2,HIGH );
      analogWrite( PWMA,100 );
      analogWrite( PWMB,100 );
      delay( 300 );
}

void giraS()// gira a sinistra************************************************
{
      alt();
      delay( 500 );
      indietro();
      delay( 500 );
      alt();
      delay( 500 );
      digitalWrite( AIN1,LOW );
      digitalWrite( AIN2,HIGH );
      digitalWrite( BIN1,HIGH );
      digitalWrite( BIN2,LOW );
      analogWrite( PWMA,100 );
      analogWrite( PWMB,100 );
      delay( 300 );
}

//valuta direzione*****************************************
int valutaDirezione() {
  alt();
  for ( int g=0; gval ) {
      direzione = g;
    }
    distanza = val;
  }
  testa.write(90);
  return direzione;
}

// routine creazione suono****************************************
void playTone() {
   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);        }                                    }                                  }     //controlla pressione pulsante e se sì passa al programma successivo**** void controllo() { val = digitalRead(inPin);   if (val == LOW) {    programma = programma + 1;     //programmi massimo 5 (volendo si può aumentare) se la variabile va a 6 viene reimpostata a 0    if (programma==6) {      programma = 0;      }    }    delay(300);   }
void prog1()// evita ostacoli***********************************************************
{

int dist = analogRead(SHIR);
if ( dist > SENSIBILITA ) {
int direz = valutaDirezione();
if ( direz == 1 ) { giraS(); }
if ( direz == 0 ) { avanti(); }
if ( direz == 2 ) { giraD(); }
}
else { avanti(); }
}

//segue oggetto**************************************************************
void prog2() {
int direz = 0;
int dist = analogRead(SHIR);
if ( dist < SENSIBILITA ) {
alt();
for ( int g=0; g<3; g++) {
if (digitalRead(inPin)==LOW) { return; }
testa.write( grad[g] );
delay(1000);
int val = analogRead(A5);
if (distanza < val ) { direz = g; }
distanza = val;
}
testa.write(90);

if ( direz == 1 ) { giraS(); }
if ( direz == 0 ) { avanti(); }
if ( direz == 2 ) { giraD(); }
} else { avanti(); }
}

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

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

}

//balletto***************************************************************
void prog4() {
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==3) { direzione=1; }
if (direzione==1) { alt(); avanti(); }
if (direzione==2) { alt(); indietro(); }
tone_ = melody[g];
duration = 1600000;
playTone(); //suona la nota
if (digitalRead(inPin)==LOW) { return; } //verifica pressione pulsante
}
}

Il primo punto importante che Anto ha modificato rispetto allo sketch originale del Robot Beginner Kit è la possibilità mediante un pulsante di variare il programma del robot:

//Programma:
//0. Fermo
//1. Movimento evitando ostacoli
//2. Movimento seguendo oggetto posto di fronte al sensore (da perfezionare)
//3. Piano virtuale: mettendo la mano di fronte al sensore a varie distanze si generano diverse note
//(da perfezionare anche questo)
//4. Balletto: il robot balla sulle note di “Fra Martino campanaro”
//5. …..

in questo modo non devi caricare lo sketch nuovo tutte le volte ma puoi semplicemente selezionare la modalità di funzionamento del robot Beginner Kit con la pressione di un pulsante.

Ma le evoluzioni non si fermano e Anto ha aggiunto al Robot Beginner Kit anche 3 led ed un buzzer per effetti sonori del robot.

L’evoluzione del circuito

Come ti ho anticipato non possiedo lo schema di montaggio ma puoi dedurlo seguendo il codice con questo semplice metodo: parti dal pulsante di selezione del programma, alla linea 074 del loop() trovi la funzione controllo() definita alle linee 219-222 in cui ad ogni pressione del pulsnate pinIN la variabile programma è incrementata di 1, se il valore va oltre il programma 5 il ciclo dei programmi ricomincia da 0;

Sai che il pulsante è collegato alla variabile pinIN, cerca questa variabile tra le definizioni e scopri che alla linea 048 la variabile pinIN definisce il pin 6 di arduino, a questo pin dovrai collegare il tuo pulsante, su come collegare un pulsante ad un uscita digitale trovi molti articoli sul blog simili a questo:

Programmare con Arduino – leggere un segnale diditale

Per il buzzer puoi seguire lo stesso metodo, cerca il punto del codice in cui viene utilizzato, la funzione playTone() (linee 234-252) mi sembra quella che cerchi, al suo interno trovi delle linee di codice tra cui solo un tipo di comando interagisce con l’Hw Arduino il digitalWrite() presente alla linea 238 e 240 al suo interno vedi la variabile speakerOut e ricercandola tra le variabili trovi che alla linea 028 è definita come A4, su questo punto non so se sia corretto utilizzare un ingresso Analogico ( A4 ) per inviargli un segnale digitale, confesso di non aver mai provato questa combinazione, proverò questo sketch appena possibile e riporterò le correzioni necessarie.

Infine i 3 led, è la parte più semplice, perchè Anto li ha dichiarati in modo parlante, ha chiamato le variabili a cui sono collegati: ledPin1, 2 e 3 e le trovi definite alle linee 044-046.

Rispetto ai miei soliti tutorial questo richiede un po’ di impegno in più e di conoscenza del Robot Beginner Kit, conoscenza che puoi approfondire in uno degli articoli:

Robot Beginner Kit con Arduino – il montaggio

Robot Beginner Kit con Arduino – l’elettronica

Robot Beginner Kit – l’evoluzione

In ogni caso sono semnpre a disposizione se vuoi un supporto o se qualcosa non è chiara.

Buon divertimento !!!

Prima di inserire un commento, per favore, leggi il regolamento

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

14 pings

Skip to comment form

  1. […] 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 […]

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.