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);
}
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);
}
...
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);
}
...
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);
}
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);
}
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);
}
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();
}
}
Descrizione sketch 6
Nota: si descrivono solo le sezioni aggiunte rispetto agli sketch precedenti.
Impostazione del sensore ad ultrasuoni
... // 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 ...
Questa sezione è dedicata all’impostazione del sensore ad ultrasuoni.
La variabile “durata” è il tempo impiegato dall’onda ultrasonica per giungere al rilevatore, questo valore verrà utilizzato per il calcolo della distanza dell’oggetto.
Le due variabili: pin_segnale e pin_trig sono quelle associate ai pin signal e trigger del sensore ad ultrasuoni.
Descrizione funzionamento loop()
...
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();
}
}
...
Nel loop() come prima azione viene memorizzata nella variabile misuraDistanza il valore restituito dalla funzione che calcola la distanza dell’ostacolo: distanzaOstacolo() che riceve le informazioni dal sensore ad ultrasuoni.
Se la distanza misurata è maggiore della distanzaPericolo, la minima distanza dall’ostacolo, allora vuol dire che EduRobot può continuare ad andare avanti, altrimenti se la misuraDistanza è inferiore alla distanza di pericolo bisogna fermare EduRobot ed effettuare il cambio di direzione.
...
{
stopEduRobot();
scegliDirezione();
}
...
Scelta della direzione da prendere
...
// 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();
}
...
EduRobot effettua una rotazione di 90° a destra, effettua la lettura ed assegna il valore letto alla variabile distanzaDestra, si ferma nella posizione per mezzo secondo.
EduRobot effettua una rotazione di 180° in senso antiorario rispetto alla precedente posizione effettua la lettura della distanza dell’ostacolo che viene memorizzata nella variabile distanzaSinistra, si ferma nella posizione per mezzo secondo.
Si pone nuovamente in posizione frontale ruotando in senso orario di 90°, mantiene la posizione ed invoca la funzione paragonaDistanze() che verifica quale delle due misure risulta maggiore.
Lettura della distanza dell’ostacolo
...
// 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;
}
...
La modalità di funzionamento di questa funzione è stata descritta nella parte iniziale della sezione dedicata allo sketch 6.
Paragonare le distanze per la scelta del percorso
...
// 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);
}
}
...
Nel caso in cui l’ostacolo che si trova a sinistra è ad una distanza maggiore da quello dell’ostacolo di destra, allora EduRobot ruoterà in senso antiorario di 90° e manterrà la posizione raggiunta per mezzo secondo.
Se invece l’ostacolo che si trova a destra si trova a distanza maggiore di quello di sinistra, allora EduRobot ruoterà in senso orario di 90° e manterrà la posizione raggiunta per mezzo secondo.
Se le distanze degli ostacoli a sinistra e a destra sono identiche, EduRobot ruota di 180° in senso orario e mantiene la posizione per 1 secondo.
Movimento continuo in avanti e indietro alla velocità scelta
...
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);
}
...
Nel codice sopra indicato avantiSempre(int velocita) permette di movimentare EduRobot in avanti ad una specifica velocità è necessario far girare la ruota sinistra in senso antiorario e lo destra in senso orario, mentre indietroSempre(int velocita) permette di muovere indietro (in retromarcia) EduRobot alla specifica velociotà è necessario far girare la ruota sinistra in senso orario e lo destra in senso antiorario.
Esercizi
Esercizio 1
Ad ogni stop del robot si accendere un led rosso.
Esercizio 2
Ad ogni stop si accendere un led rosso e durante la scelta della direzione lampeggia un led giallo.
Esercizio 3
Ad ogni stop si accendere un led rosso e durante la scelta della direzione lampeggia un led giallo, mentre il movimento in avanti ed indietro è evidenziato da un led verde acceso che dovrà spegnersi durante la scelta della direzione.
Esercizio 4
Aggiungere al circuito dell’esercizio precedente un buzzer che all’avvio del robot per 2 secondi, vengano suonate alcune note musicali.
Esercizio 5
Aggiungere al circuito dell’esercizio precedente un buzzer che all’avvio del robot per 2 secondi,emetta un jingle musicale ed ogni volta che viene effettuata la rilevazione del percorso da intraprendere vengano suonate alcune note musicali.
Esercizio 6
Aggiungere una funzione di casualità che ad intervalli prestabiliti fa cambiare direzione al robot indipendentemente dalla scelta della direzione verso l’ostacolo più lontano.
Esercizio 7
EduRobot non è dotato di un encoder, ovvero un sistema in grado di regolare la velocità delle due in modo da far andare dritto il robot, avrai notato che un motore gira ad una velocità superiore rispetto ad un’altro.
Saresti in grado di realizzare un semplice programma di calibrazione da eseguire in fase iniziale in grado di migliorare leggermente il movimento rettilineo del robot?
Buona sperimentazione a tutti 🙂