Vogliamo realizzare un robot che sia in grado di seguire autonomamente un percorso indicato da una linea nera. Useremo del nastro isolante nero per disegnare il tracciato su un banco di colore chiaro e tre sensori a infrarosso per rilevare la presenza della linea nera e correggere la direzione. Il robot consiste in:

• un telaio di supporto con una ruota a sfera sulla parte posteriore e tre sensori IR su quella anteriore
• due motori elettrici che azionano indipendentemente due ruote
• uno scheda per pilotare i due motori (il Motor Shield Arduino)
• una scheda Arduino che comanda il tutto
• un portabatterie con quattro batterie stilo (6 Volt) o un power bank per alimentare schede, motori e sensori

Il risultato finale è quello mostrato nel video:

Il Motor Shield Arduino si monta sopra la scheda Arduino e permette di collegare un motore elettrico alla scheda ¹⁾. Il componente principale dello shield, l'integrato L298, è in grado di comandare due motori in continua o un motore passo-passo grazie a due ponti H²⁾. Allo shield possono essre collegati motori da 5 a 12 Volt con correnti fino a 2 Ampère.

Lo shield utilizza 8 pin della scheda Arduino; noi ne useremo solo quattro, in particolare:

NB lo shield usa anche i pin A0 e A1 per misurare le correnti e i pin 8 e 9 per l'arresto rapido dei motori; se si vuole utilizzare ad altro scopo questi pin occorre tagliare i rispettivi collegamenti sul retro dello shield³⁾.

Comandare due motori in continua è molto semplice:

• stabiliamo la direzione di marcia dei motori impostando il valore HIGH o LOW sui pin 12 e 13
• regoliamo la velocità dei motori impostando un valore di tensione sui pin 3 e 11 (i due pin digitali vengono utilizzati come uscite analogiche grazie alla modulazione PWM)

In questo progetto utilizzeremo due motori in continua per muovere il veicolo perché le due ruote devono potersi muoversi in maniera indipendente - avanti e indietro e con velocità diverse - per cambiare direzione.

Le caratteristiche principali dei motori in continua sono:

• alimentazione in corrente continua (batterie o alimentatori) tramite due morsetti
• buone prestazioni a tutte le velocità
• facilità di controllo

Il motore si aziona applicando tensione e ruota a una velocità proporzionale al valore di tensione applicato. Per cambiare direzione bisogna invertire il verso la tensione.

Il movimento del motore viene trasmesso al carico - in questo caso le ruote - attraverso un albero motore. Più precisamente viene trasmessa una potenza meccanica che corrisponde al prodotto tra la velocità di rotazione e la coppia (la “spinta” ovvero qualcosa che ha un effetto simile a quello della forza nei moti rettilinei):

`P=C cdot omega`

dove P è la potenza in Watt (W), C la coppia in Newton per metro (Nm) e ω la velocità in radianti al secondo (rad/s)⁴⁾.

Nel nostro caso non è possibile collegare direttamente le ruote all'albero perché i motori sono costruiti per girare molto velocemente - ad esempio a 1000 giri al minuto (rpm) - e le ruote girerebbero troppo velocemente. Per questo tra i motori montati sul telaio e le ruote è posto un riduttore, un sistema ad ingranaggi che trasmette potenza meccanica riducendo la velocità, più o meno come il cambio di un'automobile o di una bicicletta.

I due motoriduttori (motore più riduttore) montati sul telaio hanno queste caratteristiche:

L'algoritmo che permette al robot di seguire la linea è molto semplice. I tre sensori sono in grado di distinguere la linea nera (che riflette poco) dal piano su cui è disegnato il tracciato (che riflette il raggio infrarosso). I motori vengono comandati considerando che:

• se il solo sensore centrale rileva la linea il veicolo può procedere dritto (entrambi i motori alla stessa velocità)
• se il sensore destro rileva la linea il veicolo deve curvare a destra per correggere la traiettoria
• se il sensore sinistro rileva la linea il veicolo deve curvare a sinistra per correggere la traiettoria

La figura seguente illustra il funzionamento dell'algoritmo (il segno giallo indica che il sensore ha rilevato la linea).

Nel programma si terrà conto anche di casi anomali; ad esempio se tutti i sensori sono attivi (o disattivi) significa che non è stata individuata la linea.

/* Progetto finale: robot che segue una linea
 * I due motori vengono comandati in base ai tre sensori a infrarosso
 * montati sulla parte frontale. Se quello centrale è sulla linea
 * il veicolo procede dritto, se la linea viene rilevata sui sensori
 * laterali il veicolo curva per riportare la linea al centro
 *
 * Nome:
 * Creato il:
 */
 
// pin che controllano la direzione del motore destro e sinistro
// valori: HIGH = avanti, LOW = indietro
int dirD = 12;
int dirS = 13;
 
// pin PWM che controllano la velocità del motore destro e sinistro
// valori: da 0 (motore fermo) a 255 (massima velocità)
int velD = 3;
int velS = 11;
 
// pin digitali collegati ai tre sensori (sinistro, centrale, destro)
int IRs = 4;
int IRc = 5;
int IRd = 6;
 
// lettura sensori
bool lineaS, lineaD, lineaC;
 
 
void setup() {
  // imposto i pin dei motori come uscite
  pinMode(dirD, OUTPUT);
  pinMode(dirS, OUTPUT);
  pinMode(velD, OUTPUT);
  pinMode(velS, OUTPUT);
  // marcia avanti per entrambi i motori
  digitalWrite(dirD, HIGH);
  digitalWrite(dirS, HIGH);
  // imposto i pin dei sensori come ingressi
  pinMode(IRs, INPUT);
  pinMode(IRd, INPUT);
  pinMode(IRc, INPUT);
  // serial debug
  Serial.begin(9600);
}
 
void loop() {
  // leggo i tre sensori (HIGH = linea nera)
  lineaS = digitalRead(IRs);
  lineaD = digitalRead(IRd);
  lineaC = digitalRead(IRc);
  Serial.print(lineaS);
  Serial.print(lineaC);
  Serial.println(lineaD);
  // linea non rilevata (tutto nero) -> alt
  if (lineaS && lineaD && lineaC){
    Serial.println("tutto nero");
    analogWrite(velD, 0);
    analogWrite(velS, 0);
  }
  // linea non rilevata (tutto bianco) -> alt
  else if (!lineaS && !lineaD && !lineaC) {
    Serial.println("tutto bianco");
    analogWrite(velD, 0);
    analogWrite(velS, 0);
  }
  // linea al centro -> dritto
  else if (lineaC && !lineaS && !lineaD) {
    Serial.println("linea al centro");
    analogWrite(velD, 200);
    analogWrite(velS, 200);
  }
  // linea a sinistra -> gira a sinistra
  else if (lineaS && !lineaC && !lineaD) {
    Serial.println("linea a sinistra");
    analogWrite(velD, 200);
    analogWrite(velS, 100);
  }
  // linea a destra -> gira a destra
  else if (lineaD && !lineaC && !lineaS) {
    Serial.println("linea a destra");
    analogWrite(velD, 100);
    analogWrite(velS, 200);
  }
  // piccolo ritardo per permettere al controllo di intervenire
  delay(10);
}

• l'algoritmo usato è decisamente primitivo e potrebbe essere perfezionato, ad esempio:
  • tenendo conto del caso in cui sia un sensore laterale che quello centrale sono attivi (nel nostro caso non viene presa alcuna decisione e la direzione di marcia resta l'ultima impostata)
  • usando l'uscita analogica dei sensori per avere un'indicazione di quanto è vicina la linea in modo da correggere la traiettoria meno bruscamente
• l'alimentazione con quattro batterie stilo è insufficiente (in parte perché il regolatore sulla scheda Arduino richiederebbe almeno 7 Volt quando si alimenta dallo spinotto e in parte perché la tensione scende notevolmente quando i motori, insieme alle due schede e ai sensori, assorbono energia); possibili soluzioni:
  • con un alimentatore a 7,5V i risultati sono molto migliori ma l'energia “non è a bordo”
  • con batteria da 9 Volt i risultati sono discreti ma occorre aggiustare la tensione/velocità del motore
• è richiesta una taratura per:
  • la sensibilità dei sensori IR per non avere false letture della linea (ombre, ecc.)
  • la velocità dei motori in modo che il controllo non sia troppo brusco

Torna all'indice.