Michele Maffucci

Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali

Pubblicato il Gennaio 22, 2019 da admin

Come sicuramente saprete i pin analogici di Arduino UNO, da A0 a A5 possono essere utilizzati anche in modalità digitale e questa caratteristica alcune volte crea qualche confusione in quanto i pin se vengono utilizzati in modalità analogica non è necessario dichiararne il pinMode all’interno del setup(), ciò ovviamente non accade se bisogna usarli in modalità digitale.
Dopo un po’ questa funzionalità viene memorizzata, un modo per non dimenticare questa caratteristica potrebbe essere quella di inserire una dichiarazione “inutile” che ne rammenta la modalità di utilizzo:

void setup() {
   Serial.begin(9600);
   analogRead(A2); // Sensore di luminosità
   pinMode(13, OUTPUT);
   pinMode(2, INPUT);
}

void setup() {

Serial.begin(9600);

analogRead(A2); // Sensore di luminosità

pinMode(13, OUTPUT);

pinMode(2, INPUT);

}

In ogni caso, per i miei studenti chiedo di ricordare a mente senza aggiungere dichiarazioni inutili, ma se si è all’inizio tale notazione può essere accettata.

Un’altra cosa che noto confonde è l’uso della notazione Ax per i pin digitali e non del valore decimale.
In Arduino.h viene definito ad esempio A2 come una costante di tipo intero. Su Arduino UNO ad A2 è assegnato il valore numerico 16 e poiché è una costante di tipo intero possiamo trattare a tutti gli effetti A2 come se si trattasse del numero 16.

Per completezza ricordo che:

A0 -> 14
A1 -> 15
A2 -> 16
A3 -> 17
A4 -> 18
A5 -> 19

In generale sconsiglio di indicare i pin analogici con il loro valore numerico per due motivi:

la notazione Ax immediatamente mette in evidenza che si tratta di pin analogico,
se utilizziamo su una scheda con più pin I/O, come un Arduino Mega non andremo in confusione e non rischieremo far andare in collisione un pin digitale con un pin analogico nel caso ad esempio che stessimo mettendo mano ad uno sketch funzionante su Arduino Uno e che vogliamo far funzionare sul Mega, infatti su Arduino UNO l’A0 corrisponde al pin 14 della scheda mentre sull’Arduino Mega corrsiponde al pin 54 della scheda, se usiamo la notazione Ax non ci sbagliamo.

Ricordate inoltre che se all’interno del nostro loop() passiamo ad una digitalRead un valore da 0 a 5 non intendiamo segnalare un pin digitale da 0 a 5, ma uno dei pin da A0 ad A5.

Buon lavoro 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato analog, arduino, digital, equal, errori, pin, programmazione | Lascia un commento

EduRobot – ASL (Alternanza Scuola Lavoro) – Manuale di costruzione – 3/3

Pubblicato il Gennaio 22, 2019 da admin

Nella guida che segue illustro un schema molto semplice per la realizzazione del controllo di EduRobot effettuata con Arduino. Fornirò passo passo gli sketch di esempio che dovrete migliorare. è può essere considerato la base di partenza per ogni sperimentazione basata appunto su Arduino.
Per il pilotaggio dei motori ho utilizzato e L298N Dual H-Bridge Motor Controller di cui vi ho dato indicazioni nella lezione precedente.

Ovviamente anche la soluzione proposta in questo tutorial potranno essere migliorate da voi, lo scopo è quello di svolgere l’attività di Alternanza Scuola Lavoro di questi giorni, ma nelle settimane che seguiranno potrete migliorare ogni aspetto del robot in quanto il corso su Arduino che state svolgendo nelle mie ore sarà svolto proprio sulla piattaforma EduRobot.

Potrete sostituire alle batterie che io ho utilizzato, batterie ricarrabili, o pacchi batterie con autonomia maggiore che potrete fissare utilizzando gli appositi fori predisposti sullo chassis, durante le lezioni in classe vi fornirò suggerimenti e modalità diverse di utilizzo della scheda L298N.

Nelle parti che seguono costruiamo passo passo il programma che consente la realizzaizone di un robot che si muove in modo autonomo.

Negli esempio che seguono verranno di volta aggiunte nuove funzioni, la lista completa è la seguente:

rotazioneOraria(tempo necessario per effettuare una determinata rotazione, velocità con cui ruota il robot)

Rotazione oraria di EduRobot sul proprio asse

stopEduRobot()

Blocca il movimento del robot

distanzaOstacolo()

restituisce la distanza in cm dell’ostacolo rilevato

paragonaDistanze()

verifica la distanza dell’ostacolo che si trova a distanza maggiore dal robot

scegliDirezione()

sceglie la direzione da prendere in funzione della distanza a cui si trova l’ostacolo

La spiegazione del funzionamento d ogni parte del codice è inclusa all’interno dello sketch come commento.

Nota per lo studio:

i 6 sketch proposti variano solo nel loop per la realizzazione delle funzioni richieste, la variazione tra uno sketch e l’altro consiste nell’aggiunta di poche linee di codice, sarà quindi necessario effettuare uno studio preliminare di tutte le parti dello sketch 1.

Sketch 1

Rotazione di 90° in senso orario del robot sul proprio asse e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 4
  Rotazione di 90° in senso orario del robot sul proprio asse
  e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;
int direzione2_M1 = 3;
int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;
int direzione2_M2 = 5;
int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200;               // velocità di rotazione dei motori. Valore compreso tra 0 e 255
int velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

  // modalità di utilizzo dei pin di controllo
  pinMode(direzione1_M1, OUTPUT);
  pinMode(direzione2_M1, OUTPUT);
  pinMode(velocita_M1, OUTPUT);
  pinMode(direzione1_M2, OUTPUT);
  pinMode(direzione2_M2, OUTPUT);
  pinMode(velocita_M2, OUTPUT);

  delay(attesa);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

void loop() {
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 4

Rotazione di 90° in senso orario del robot sul proprio asse

e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

Collegamenti:

L298N --> Arduino

ENB --> Pin 10

IN4 --> Pin 5

IN3 --> Pin 4

IN2 --> Pin 3

IN1 --> Pin 2

ENA --> Pin 9

+12V --> Vin

GND --> GND

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;

int direzione2_M1 = 3;

int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;

int direzione2_M2 = 5;

int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200; // velocità di rotazione dei motori. Valore compreso tra 0 e 255

int velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

// modalità di utilizzo dei pin di controllo

pinMode(direzione1_M1, OUTPUT);

pinMode(direzione2_M1, OUTPUT);

pinMode(velocita_M1, OUTPUT);

pinMode(direzione1_M2, OUTPUT);

pinMode(direzione2_M2, OUTPUT);

pinMode(velocita_M2, OUTPUT);

delay(attesa);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

void loop() {

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

}

Dalla lezione precedente si sono utilizzati le parti di sketch che permettono la rotazione in senso antiorario ed orario dei motori.

La funzione rotazioneOraria e rotazioneAntioraria, di seguito evidenziate, consentono la rotazione di EduRobot sul proprio asse in una delle due direzioni. Le funzioni accettano due parametri:

tempo: tempo per compiere uno specifico angolo di rotazione
velocita_rotazione: velocità con cui gira il robot

Il tempo per compiere un angolo di 90° deve essere valutato sperimentalmente in quanto funzione della carica della batteria. Per regolare il tempo di rotazione per un angolo di 90° variare il valore della variabile globale: tempo_rotazione_angolo che trovate all’inizio dello sketch.

...
void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}
...

...

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

...

...
void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}
...

...

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

...

Per interrompere la rotazione di EduRobot è sufficiente inviare sui pin 9 e 5 di Arduino di tipo PWM il valore 0

...
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}
...

...

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

...

Sketch 2

Rotazione di 180° in senso orario del robot sul proprio asse e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

Per eseguire questa esercitazione sarà sufficiente aggiungere allo sketch precedente un’ulteriore chiamata alle funzioni rotazioneOraria e rotazioneAntioraria, oppure variare il valore della variabile tempo_rotazione_angolo per un tempo doppio rispetto al tempo necessario per compiere una rotazione di 90°.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 5
  Rotazione di 180° in senso orario del robot sul proprio asse e
  ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;
int direzione2_M1 = 3;
int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;
int direzione2_M2 = 5;
int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200;               // velocità di rotazione dei motori. Valore compreso tra 0 e 255
int velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

  // modalità di utilizzo dei pin di controllo
  pinMode(direzione1_M1, OUTPUT);
  pinMode(direzione2_M1, OUTPUT);
  pinMode(velocita_M1, OUTPUT);
  pinMode(direzione1_M2, OUTPUT);
  pinMode(direzione2_M2, OUTPUT);
  pinMode(velocita_M2, OUTPUT);

  delay(attesa);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

void loop() {
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 5

Rotazione di 180° in senso orario del robot sul proprio asse e

ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

Collegamenti:

L298N --> Arduino

ENB --> Pin 10

IN4 --> Pin 5

IN3 --> Pin 4

IN2 --> Pin 3

IN1 --> Pin 2

ENA --> Pin 9

+12V --> Vin

GND --> GND

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;

int direzione2_M1 = 3;

int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;

int direzione2_M2 = 5;

int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200; // velocità di rotazione dei motori. Valore compreso tra 0 e 255

int velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

// modalità di utilizzo dei pin di controllo

pinMode(direzione1_M1, OUTPUT);

pinMode(direzione2_M1, OUTPUT);

pinMode(velocita_M1, OUTPUT);

pinMode(direzione1_M2, OUTPUT);

pinMode(direzione2_M2, OUTPUT);

pinMode(velocita_M2, OUTPUT);

delay(attesa);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

void loop() {

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

}

Sketch 3

Rotazione di 360° in senso orario del robot sul proprio asse, rotazione di 360° in senso antiorario del robot sul proprio asse con intervallo di stop a 180° di 1 secondo e stop di 3 secondi a 360°.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 6
  Rotazione di 360° in senso orario del robot sul proprio asse, rotazione di 360°
  in senso antiorario del robot sul proprio asse con intervallo di stop a 180°
  di 1 secondo e stop di 3 secondi a 360°.

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;
int direzione2_M1 = 3;
int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;
int direzione2_M2 = 5;
int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200;               // velocità di rotazione dei motori. Valore compreso tra 0 e 255
int velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

  // modalità di utilizzo dei pin di controllo
  pinMode(direzione1_M1, OUTPUT);
  pinMode(direzione2_M1, OUTPUT);
  pinMode(velocita_M1, OUTPUT);
  pinMode(direzione1_M2, OUTPUT);
  pinMode(direzione2_M2, OUTPUT);
  pinMode(velocita_M2, OUTPUT);

  delay(attesa);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

void loop() {

  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);
  
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);

  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);
  
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 6

Rotazione di 360° in senso orario del robot sul proprio asse, rotazione di 360°

in senso antiorario del robot sul proprio asse con intervallo di stop a 180°

di 1 secondo e stop di 3 secondi a 360°.

Collegamenti:

L298N --> Arduino

ENB --> Pin 10

IN4 --> Pin 5

IN3 --> Pin 4

IN2 --> Pin 3

IN1 --> Pin 2

ENA --> Pin 9

+12V --> Vin

GND --> GND

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;

int direzione2_M1 = 3;

int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;

int direzione2_M2 = 5;

int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200; // velocità di rotazione dei motori. Valore compreso tra 0 e 255

int velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

// modalità di utilizzo dei pin di controllo

pinMode(direzione1_M1, OUTPUT);

pinMode(direzione2_M1, OUTPUT);

pinMode(velocita_M1, OUTPUT);

pinMode(direzione1_M2, OUTPUT);

pinMode(direzione2_M2, OUTPUT);

pinMode(velocita_M2, OUTPUT);

delay(attesa);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

void loop() {

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

}

Facendo eseguire ad EduRobot i medesimi spostamenti, ottimizzare il codice presente nel loop riducendo il numero di istruzioni.

Sketch 4

Ripetere la sequenza: avanti per 500 millisecondi, stop per 3 secondi, rotazione di 180° in senso orario del robot, stop di 1 secondo, avanti per 500 millisecondi, stop di 3 secondi, rotazione di 180° in senso antiorario, stop di 1 secondo, movimento in avanti per 500 millisecondi.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 7
  Sequenza: avanti per 500 millisecondi, stop per 3 secondi, rotazione di 180° in senso orario del robot,
  stop di 1 secondo, avanti per 500 millisecondi, stop di 3 secondi, rotazione di 180° in senso antiorario,
  stop di 1 secondo, movimento in avanti per 500 millisecondi.

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;
int direzione2_M1 = 3;
int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;
int direzione2_M2 = 5;
int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200;               // velocità di rotazione dei motori. Valore compreso tra 0 e 255
int velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse
int velocita_avanti = 150;        // velocità di avanzamento in avanti di EduRobot

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

  // modalità di utilizzo dei pin di controllo
  pinMode(direzione1_M1, OUTPUT);
  pinMode(direzione2_M1, OUTPUT);
  pinMode(velocita_M1, OUTPUT);
  pinMode(direzione1_M2, OUTPUT);
  pinMode(direzione2_M2, OUTPUT);
  pinMode(velocita_M2, OUTPUT);

  delay(attesa);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

// Movimento in Avanti di EduRobot
void avantiPer(int tempo_avanti)
{
  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_avanti); // Imposta la velocità del motore M1 a velocita_avanti
  analogWrite(velocita_M2, velocita_avanti); // Imposta la velocità del motore M2 a velocita_avanti

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_avanti);

}

void loop() {

  // avanti per 500 millisecondi, stop per 3 secondi
  avantiPer(500);
  stopEduRobot();
  delay(3000);

  // rotazione di 180° in senso orario del robot, stop di 1 secondo
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);

  // avanti per 500 millisecondi, stop di 3 secondi
  avantiPer(500);
  stopEduRobot();
  delay(3000);

  // rotazione di 180° in senso antiorario, stop di 1 secondo
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 7

Sequenza: avanti per 500 millisecondi, stop per 3 secondi, rotazione di 180° in senso orario del robot,

stop di 1 secondo, avanti per 500 millisecondi, stop di 3 secondi, rotazione di 180° in senso antiorario,

stop di 1 secondo, movimento in avanti per 500 millisecondi.

Collegamenti:

L298N --> Arduino

ENB --> Pin 10

IN4 --> Pin 5

IN3 --> Pin 4

IN2 --> Pin 3

IN1 --> Pin 2

ENA --> Pin 9

+12V --> Vin

GND --> GND

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;

int direzione2_M1 = 3;

int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;

int direzione2_M2 = 5;

int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200; // velocità di rotazione dei motori. Valore compreso tra 0 e 255

int velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int velocita_avanti = 150; // velocità di avanzamento in avanti di EduRobot

int attesa = 3000; // tempo di attesa prima che il robot si muova

void setup() {

// modalità di utilizzo dei pin di controllo

pinMode(direzione1_M1, OUTPUT);

pinMode(direzione2_M1, OUTPUT);

pinMode(velocita_M1, OUTPUT);

pinMode(direzione1_M2, OUTPUT);

pinMode(direzione2_M2, OUTPUT);

pinMode(velocita_M2, OUTPUT);

delay(attesa);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200

analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

// Movimento in Avanti di EduRobot

void avantiPer(int tempo_avanti)

{

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

analogWrite(velocita_M1, velocita_avanti); // Imposta la velocità del motore M1 a velocita_avanti

analogWrite(velocita_M2, velocita_avanti); // Imposta la velocità del motore M2 a velocita_avanti

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo_avanti);

}

void loop() {

// avanti per 500 millisecondi, stop per 3 secondi

avantiPer(500);

stopEduRobot();

delay(3000);

// rotazione di 180° in senso orario del robot, stop di 1 secondo

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

// avanti per 500 millisecondi, stop di 3 secondi

avantiPer(500);

stopEduRobot();

delay(3000);

// rotazione di 180° in senso antiorario, stop di 1 secondo

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

}

Sketch 5

Realizzare uno sketch che permetta di realizzare in sequenza le tre rotazioni:

45° in senso antiorario del robot
dalla posizione raggiunta rotazione di 90° in senso orario
dalla posizione raggiunta, rotazione di 45° in senso antiorario

Sketch 6

Utilizzando il sensore ad ultrasuoni HC-SR04 per rilevare gli ostacoli ed effettuare la scelta della direzione da intraprendere in funzione dell’ostacolo che si trova a distanza maggiore dal robot.

Funzionamento del sensore HC-SR04

Per l’utilizzo del sensore ad ultrasuoni ne avevo già dato spiegazione in EduRobot UNO – Come costruire il vostro primo Arduino Robot – Lezione 2 ma per permetterne un’agevole studio duplico quanto già scritto nel tutorial in modo che abbiate un punto unico di riferimento.

Per far evitare gli ostacoli al nostro robot utilizzeremo un sensore ad ultrasuoni, in altro modo useremo questo sensore per misurare la distanza dell’ostacolo, ma potremo anche pensare di usare questo sensore, ad esempio, in un sistema anti-intrusione che deve far suonare un allarme. In questa lezione viene utilizzato il sensore HC-SR04, dispositivo economico e con un buon range operativo, ha una sensibilità dichiarata nei datasheet che va da 2 centimetri a 4,5 metri circa, in realtà la massima distanza da esperimenti che ho effettuato arriva a circa 3,5 metri, molto comunque dipende dai materiali colpiti e dalla loro capacità di assorbimento sonoro.

Ma come funziona un sensore di questo tipo?

I sensori ad ultrasuoni non forniscono direttamente la misura della distanza dell’oggetto più vicino, ma misurano il tempo impiegato da un segnale sonoro a raggiungere l’oggetto e ritornare al sensore.

L’impulso ad ultrasuoni inviato all’HC-SR04 è di circa 40KHz il tempo viene misurato in microsecondi, la tensione di funzionamento è di 5V, quindi potremo alimentarlo direttamente utilizzando Arduino.

L’HC-SR04 è dotato di 4 piedini: GND, eco, trigger, +Vcc.

Per convertire l’intervallo di tempo misurato in una lunghezza, bisogna ricordare che la velocità del suono è di 331,5 m/s a 0 °C e di 343,4 m/s a 20 °C ed in generale varia secondo la relazione:

v = 331,4 + 0,62 T

dove la temperatura T è misurata in °C.

Per effettuare una misura di distanza di un ostacolo assumiamo di lavorare ad una temperatura ambiente di 20 °C e quindi la velocità del suono sarà di 343 m/s (approssimiamo) che vuol dire anche 0,0343 cm/microsecondi.

Quindi, ricordando che v=s/t (v: velocità, s: spazio, t: tempo) allora lo spazio percorso sarà:

s = v*t

da cui

s = 0,0343 *t

però, per calcolare lo spazio percorso, bisogna tener conto che il suono percorre due volte la distanza da misurare (giunge sull’oggetto e ritorna indietro al sensore) quindi il valore di t ottenuto deve essere diviso per 2. La formula corretta per la misura dello spazio percorso è:

s = 0,0343 * t/2

eseguendo la divisione di 0,0343/2 possiamo scrivere:

s = 0,01715 * t

oppure:

s = t/58,31

approssimando

s = t/58

formula più semplice da ricordare.

Per calcolare la distanza dell’oggetto dal sensore sarà sufficiente dividere il tempo t (tempo impiegato dal segnale per giungere sull’oggetto e tornare al sensore) per 58.

Per poter effettuare una misurazione viene mantenuto a livello basso il pin Trigger, dopo di che viene fornito un impulso a livello alto della durata minima di 10µs riportandolo poi a livello basso, dopo questo momento la capsula trasmittente emette un burst (sequenza di livelli alti/bassi) a circa 40KHz, l’onda ultrasonica generata (burst) colpisce l’ostacolo, torna indietro venendo rilevata dalla capsula ricevente. L’elettronica del sensore effettua un calcolo del tempo di andata e ritorno del segnale emettendo sul pin Echo, normalmente a livello basso, un segnale a livello alto direttamente proporzionale alla distanza dell’ostacolo:

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 8
  Utilizzando il sensore ad ultrasuoni rilevare gli ostacoli ed effettuare la scelta
  della direzione da intraprendere in funzione dell’ostacolo che si
  trova a distanza maggiore dal robot.

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;
int direzione2_M1 = 3;
int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;
int direzione2_M2 = 5;
int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200;               // velocità di rotazione dei motori. Valore compreso tra 0 e 255
int velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse
int velocita_avanti = 150;        // velocità di avanzamento in avanti di EduRobot

int attesa = 3000; // tempo di attesa prima che il robot si muova

// Impostazione sensore ultrasuoni
const int distanzaPericolo = 20;      // distanza minima dell'ostacolo (in cm)
int distanzaSinistra, distanzaDestra; // distanza sinistra e destra
int misuraDistanza = 0;

long durata;            // durata dell'impulso
long distanza;          // distanza dell'oggetto
int pin_segnale = 7;    // pin Arduino a cui è collegato il sensore SR04
int pin_trig = 6;       // pin Arduino a cui è collegato il sensore SR04

void setup() {

  // modalità di utilizzo dei pin di controllo
  pinMode(direzione1_M1, OUTPUT);
  pinMode(direzione2_M1, OUTPUT);
  pinMode(velocita_M1, OUTPUT);
  pinMode(direzione1_M2, OUTPUT);
  pinMode(direzione2_M2, OUTPUT);
  pinMode(velocita_M2, OUTPUT);

  // impostazione pin per sensore ultrasuoni SR04
  pinMode(pin_trig, OUTPUT);
  pinMode(pin_segnale, INPUT);

  delay(attesa);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M1, velocita_rotazione); // Imposta la velocità del motore M1 a velocità = 200
  analogWrite(velocita_M2, velocita_rotazione); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

// Movimento in Avanti di EduRobot
void avantiPer(int tempo_avanti)
{
  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_avanti); // Imposta la velocità del motore M1 a velocita_avanti
  analogWrite(velocita_M2, velocita_avanti); // Imposta la velocità del motore M2 a velocita_avanti

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_avanti);

}

void avantiSempre(int velocita)
{

  // Motore 1 (Sx) - senso antiorario

  analogWrite(velocita_M1, velocita); // Imposta la velocità del motore M1 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);

  // Motore 2 (Dx) - senso orario

  analogWrite(velocita_M2, velocita); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M2 (Dx) in senso orario
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
}

// Indietro senza stop
void indietroSempre(int velocita)
{

  // Motore 1 (Sx) - in senso orario

  analogWrite(velocita_M1, velocita); // Imposta la velocità del motore M1 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);

  // Motore 2 (Dx) - senso antiorario

  analogWrite(velocita_M2, velocita); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M2 (Dx) in senso antiorario
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
}

// restituisce la distanza in cm dell’ostacolo rilevato
long distanzaOstacolo()
{
  digitalWrite(pin_trig, LOW);
  delayMicroseconds(2);
  digitalWrite(pin_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin_trig, LOW);
  durata = pulseIn(pin_segnale, HIGH);
  distanza = (durata / 2) / 29.1;
  delay(100);
  return distanza;
}

// verifica la distanza dell’ostacolo che si trova a distanza maggiore dal robot
void paragonaDistanze()
{
  if (distanzaSinistra > distanzaDestra) // vai a sinistra perchè ostacolo a sx più lontano
  {
    rotazioneAntioraria(tempo_rotazione_angolo, velocita_scelta_dir);
    delay(500);
  }
  else if (distanzaDestra < distanzaSinistra) // vai a destra perchè ostacolo a dx più lontano
  {
    rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
    delay(500);
  }
  else // se le distanze degli ostacoli a
  { // sx e dx sono uguali gira di 180 gradi (circa)
    rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
    rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
    delay(1000);
  }
}

// sceglie la direzione da prendere in funzione della distanza a cui si trova l’ostacolo
void scegliDirezione() {
  rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
  distanzaDestra = distanzaOstacolo();   // lettura distanza ostacolo di dx
  delay(500);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_scelta_dir);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_scelta_dir);
  distanzaSinistra = distanzaOstacolo(); // lettura distanza ostacolo di sx
  delay(500);
  rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
  delay(100);
  paragonaDistanze();
}

void loop() {
  misuraDistanza = distanzaOstacolo();
  if (misuraDistanza > distanzaPericolo) // vai avanti
  {
    avantiSempre(velocita_avanti);                      // se non ci sono ostacoli vai avanti
  }
  // valutazione dell'ostacolo che si trova a distanza maggiore
  // se l'ostacolo si trova a distanza minore di "distanzaPericolo"
  // bisogna scegliere la direzione
  else
  {
    stopEduRobot();
    scegliDirezione();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 8

Utilizzando il sensore ad ultrasuoni rilevare gli ostacoli ed effettuare la scelta

della direzione da intraprendere in funzione dell’ostacolo che si

trova a distanza maggiore dal robot.