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.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
... 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); } ... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
... 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°.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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); 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°.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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); 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.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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); 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:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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. 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()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
... 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
... // 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
... 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 🙂
Mi piace:
Mi piace Caricamento...
Articoli simili:
