Crea sito

Codice Roby per movimento , riconoscimento colori e riconoscimento di oggetti in prossimità

ITIS “F.GIORDANI” Caserta
A.S. 2017/18
classe: 4D informatica
indirizzo di studio: Informatica e Telecomunicazione – articolazione Informatica
Materia: Informatica
Programmatore:Bonomo Alessandro
Sistema Operativo: Windows 10
Linguaggio: Arduino
Obiettivo didattico:
Programmare Roby, usando il sensore di  colore, di prossimità e il motore.
Obiettivo dell’esercitazione:
Programmare Roby per farlo muovere riconoscendo i colori.
Elenco attrezzature e materiali:
  1. Scheda arduino.
  2. Breadboard.
  3. Chip motore L293D.
  4. Sensore di prossimità
  5. Sensore di colore
  6. Cavo usb per collegare Arduino.

 

 

 

Codice Arduino(vers. 2.0):

//inizio classe sensore di colore
class sensoreColore
{
private:
int r,g,b; //colori
int out = 7; //rileva il segnale in ingresso all’Arduino
int s0 = 1; //rileva la Frequenza
int s1 = 2; //rileva la Frequenza
int s2 = 3; //rileva il Colore
int s3 = 4; //rileva il Colore
public:
sensoreColore()
{
//configurazione di default
out = 2;
s0 = 3;
s1 = 4;
s2 = 5;
s3 = 6;
pinMode(s0, OUTPUT);
pinMode(s1, OUTPUT);
pinMode(s2, OUTPUT);
pinMode(s3, OUTPUT);
pinMode(out, INPUT);
//Frequenza al 100/100
digitalWrite(s0, HIGH);
digitalWrite(s1, HIGH);
}
sensoreColore(int out,int s0,int s1,int s2,int s3)
{
//configurazione con parametri
this->out=out;
this->s0=s0;
this->s1=s1;
this->s2=s2;
this->s3=s3;
pinMode(s0, OUTPUT);
pinMode(s1, OUTPUT);
pinMode(s2, OUTPUT);
pinMode(s3, OUTPUT);
pinMode(out, INPUT);
//Frequenza al 100/100
digitalWrite(s0, HIGH);
digitalWrite(s1, HIGH);
}
int rilevaBlue()
{
int b;
digitalWrite(s2, LOW);
digitalWrite(s3, HIGH);
b = pulseIn(out, digitalRead(out));
return b;
}

int rilevaVerde()
{
int v;
digitalWrite(s3, HIGH);
digitalWrite(s2, HIGH);
v = pulseIn(out, digitalRead(out));
return v;
}

int rilevarosso()
{
int r;
digitalWrite(s2, LOW);
digitalWrite(s3, LOW);
r = pulseIn(out, digitalRead(out));
return r;
}

};

// inizio classe driverL293D
class driverL293D
{
private:
int pinSxAvanti; // motore di sinistra ,pin attivazione direzione avanti
int pinDxAvanti; // motore di destra ,pin attivazione direzione avanti
int pinSxIndietro; // motore di sinistra ,pin attivazione direzione indietro
int pinDxIndietro; // motore di destra ,pin attivazione direzione indietro
public:
driverL293D()
{
//configurazione di default
this->pinSxAvanti=2;
this->pinDxAvanti=3;
this->pinSxIndietro=4;
this->pinDxIndietro=5;
pinMode(pinSxAvanti , OUTPUT);
pinMode(pinDxAvanti , OUTPUT);
pinMode(pinSxIndietro , OUTPUT);
pinMode(pinDxIndietro , OUTPUT);
}
driverL293D(int pinSxAvanti,int pinDxAvanti,int pinSxIndietro,int pinDxIndietro)
{
//configurazione con pin come parametri
this->pinSxAvanti=pinSxAvanti;
this->pinDxAvanti=pinDxAvanti;
this->pinSxIndietro=pinSxIndietro;
this->pinDxIndietro=pinDxIndietro;
pinMode(pinSxAvanti , OUTPUT);
pinMode(pinDxAvanti , OUTPUT);
pinMode(pinSxIndietro , OUTPUT);
pinMode(pinDxIndietro , OUTPUT);
}
void avantiDi(int millisec)
{
digitalWrite(pinSxAvanti , 1);
digitalWrite(pinDxAvanti , 0);
digitalWrite(pinSxIndietro , 1);
digitalWrite(pinDxIndietro , 0);
int tempo=0;
while(millisec-tempo>0)
{
delay(1);
tempo++;
}
fermo();
}
void indietroDi(int millisec)
{
digitalWrite(pinSxAvanti , 0);
digitalWrite(pinDxAvanti , 1);
digitalWrite(pinSxIndietro , 0);
digitalWrite(pinDxIndietro , 1);
int tempo=0;
while(millisec-tempo>0)
{
delay(1);
tempo++;
}
fermo();
}
private:
void fermo()
{
digitalWrite(pinSxAvanti , 0);
digitalWrite(pinDxAvanti , 0);
digitalWrite(pinSxIndietro , 0);
digitalWrite(pinDxIndietro , 0);
}
};

// inizio classe sensore di prossimità
class classSensoreProssimita
{
private:
int pinEcho;
int pinTrigger;
static const float v=0.034; // velocità del suono in una temperatura media di 20° in cm/s
public:
classSensoreProssimita()
{
// configurazione di default
pinEcho=2;
pinTrigger=3;
pinMode( pinEcho, INPUT );
pinMode( pinTrigger, OUTPUT );
}
classSensoreProssimita(int pinEcho,int pinTrigger)
{
this->pinEcho=pinEcho;
this->pinTrigger=pinTrigger;
pinMode( pinTrigger, OUTPUT );
pinMode( pinEcho, INPUT );
}
long getDistanzaLetta() // ritorna la distanza letta in cm
{
digitalWrite( pinTrigger, LOW );
digitalWrite( pinTrigger, HIGH );
delayMicroseconds( 10 );
digitalWrite( pinTrigger, LOW );
long t = pulseIn( pinEcho, HIGH );
long s = v * t / 2;
return s;
}
};

// dichiarazione pin
const int pinSxAvanti=2;
const int pinDxAvanti=3;
const int pinSxIndietro=4;
const int pinDxIndietro=5;
const int pinEcho = 6;
const int pinTrigger = 7;
const int ledrosso = 13;
const int ledSegnalazRosso=A0;
const int ledSegnalazVerde=A1;
const int ledSegnalazBlue=A2;
const int pinOut=8;
const int s0=9;
const int s1=10;
const int s2=11;
const int s3=12;
// oggetti delle classi
driverL293D driverMotoriObj(pinSxAvanti, pinDxAvanti, pinSxIndietro, pinDxIndietro);
classSensoreProssimita sensProssObj(pinEcho,pinTrigger);
sensoreColore sensoreColoreObj(pinOut,s0,s1,s2,s3);
void setup()
{
Serial.begin(9600);
pinMode( ledrosso, OUTPUT );
pinMode(ledSegnalazRosso,OUTPUT);
pinMode(ledSegnalazVerde,OUTPUT);
pinMode(ledSegnalazBlue,OUTPUT);
// vai avanti per x millisecondi
driverMotoriObj.avantiDi(5000);
// vai avanti per x millisecondi
driverMotoriObj.indietroDi(5000);
}
void loop()
{
int pausa=100;
int r,v,b; //colori
r=sensoreColoreObj.rilevarosso();
v=sensoreColoreObj.rilevaVerde();
b=sensoreColoreObj.rilevaBlue();
if (r < b && r < v )
{
// Se la Frequenza del rosso è minore del verde e del blu, prevale il colore Rosso
digitalWrite(ledSegnalazRosso,1);
digitalWrite(ledSegnalazVerde,0);
digitalWrite(ledSegnalazBlue,0);
Serial.println(“prevale il colore rosso”);
Serial.print(“rosso=”);
Serial.println(r);
Serial.print(“verde=”);
Serial.println(v);
Serial.print(“blue=”);
Serial.println(b);
delay (pausa);
}

if (v < r && v < b)
{
// Se la Frequenza del verde è minore del rosso e del blu, prevale il colore Verde
digitalWrite(ledSegnalazRosso,0);
digitalWrite(ledSegnalazVerde,1);
digitalWrite(ledSegnalazBlue,0);
Serial.println(“prevale il colore Verde”);
Serial.print(“rosso=”);
Serial.println(r);
Serial.print(“verde=”);
Serial.println(v);
Serial.print(“blue=”);
Serial.println(b);
delay (pausa);
}

if (b<r && b < v )
{
// Se la Frequenza del blu è minore del verde e del rosso, prevale il colore Blu
digitalWrite(ledSegnalazRosso,0);
digitalWrite(ledSegnalazVerde,0);
digitalWrite(ledSegnalazBlue,1);
Serial.println(“prevale il colore Blu”);
Serial.print(“rosso=”);
Serial.println(r);
Serial.print(“verde=”);
Serial.println(v);
Serial.print(“blue=”);
Serial.println(b);
delay (pausa);
}
long dist=sensProssObj.getDistanzaLetta();
if( dist <= 10)
{
digitalWrite(ledrosso, LOW);
}
else
{
digitalWrite(ledrosso, HIGH);
}
delay(10); // Faccio respirare un pò il ciclo
}

Descrizione top-down dei passi realizzativi:

  1. Realizzare il circuito
  2. Scrivere il codice arduino
  3. Collegare la scheda arduino al pc tramite il cavo usb
  4. Caricare il programma cliccando sul pulsante “carica” dell‘ambiente software arduino

Test finale:
Osservare il funzionamento di Roby.

Comments are closed.