Robot segui linea di Stefano Maiocchi

Il venerdì è spesso dedicato ai progetti come il robot segui linea che appassionati arduino e makes, come te e come Stefano, mi inviate con la voglia di condividerli.

Ed oggi 1 Maggio non poteva essere giorno migliore per presentare un progetto interessante come il robot segui linea di Stefano Maiocchi, perché così io mi riposo :-).

Stefano si presenta così:

Salve sono un appassionato utilizzatore di Arduino da un anno, e dopo aver giocato con vari trasduttori e attuatori vi presento il mio primo progetto completo.

Il progetto robot segui linea

Stefano scrive:

Si tratta di un robot 2WD ma non è uno dei vari KIT che si trovano in commercio. Da buon maker ho cercato in internet una struttura con motori che poi ho adattato agli altri componenti lavorando con trapano, lima e altri attrezzi. Inoltre ho realizzato personalmente i sensori per rilevare la linea e  i bordi saldando su basetta millefori tradizionali componenti : diodo led e fototransistor all’infrarosso 3mm e resistori da 1/4 W.

La particolarità di questo lavoro è duplice.

1. Hardware: Realizzarlo in forte economia (circa 25 euro tutto compreso: scheda controllo motori, telaio, motori, ruote, trasduttori, servomotore, sensore ad ultrasuoni con supporto e viti varie)
2. Software: ottenere un robot adatto a percorsi impegnativi con curve molto strette e curve a L cioè a 90 gradi e di tipo a spigolo ( vedi il video in fondo )

Poi ti racconta un po’ di storia su come è nato il robot segui linea e quale è stato il percorso di studio/lavoro e sperimentazione che ha spinto Stefano a realizzare la sua versione di questo robot:

Ho iniziato leggendo il famoso libro “Make an Arduino-Controlled Robot” del mitico Michael Margolis, di cui esiste anche la versione italiana edita da Tecniche Nuove. Ho provato tutti gli sketch e giunto a quello per seguire una linea ho notato un problema, stringendo il raggio della curva a meno di 25 cm vi era scarsa efficienza.

Siccome sono riuscito a migliorare il suo sketch ottenendo il buon risultato visibile nel video, vorrei condividerlo con eventuali altri appassionati interessati. Se però state pensando di partecipare alla RoboCUP JR per alunni delle scuole medie sappiate che il mio sketch è solo un punto di partenza; bisogna modificare la gestione delle curve a L (io uso solo due sensori per seguire la linea, bisogna tener conto anche del terzo centrale) e bisogna implementare un controllo di potenza motore per salire le rampe.

Lo sketch del robot segui linea

Lo sketch che Stefano ha scritto e desidera condividere si compone di circa 60 righe ricche di concetti che analizziamo linea per linea:

/*************************************************************************
RobotSeguiLinea.ino
Maiocchi Stefano. Vigevano (PV)
Ispirato dal libro Make an Arduino-Controlled Robot
di Michael Margolis (O'Reilly)
*************************************************************************/

#include <AFMotor.h>      // adafruit motor shield library
#include "RobotMotor.h"   // 2wd motor library by Margolis

int speed = MIN_SPEED + 5;     // velocità percentuale motori del robot
const int SENSE_IR_LEFT   = 2; // pin analogico A2 sensore sinistro linea
const int SENSE_IR_RIGHT  = 3; // pin analogico A3 sensore destro linea

void setup()
{
  delay(1000);
  bitClear(ADCSRA,ADPS0);   // set ADC
  bitClear(ADCSRA,ADPS1);   // frequency conversion
  bitSet(ADCSRA,ADPS2);     // 1MHz (default 125KHz)
  motorBegin(MOTOR_LEFT); 
  motorBegin(MOTOR_RIGHT); 
  motorStop(MOTOR_LEFT);
  motorStop(MOTOR_RIGHT);
}

void loop()
{
  int drift = lineSense();
  lineFollow(drift, speed);
}

/****************************
   Line  Sensor code   
****************************/

// drift = 0 se sopra linea, < 0 se a destra, > 0 se a sinistra
int lineSense()
{
  int leftVal = analogRead(SENSE_IR_LEFT);
  int rightVal = analogRead(SENSE_IR_RIGHT);
  int drift = (leftVal - rightVal);
  return drift;
}

//segue la linea
int lineFollow(int drift, int speed)
{
  if ( (speed + drift)>0 )
  {
    int rightSpeed  =  constrain(speed + drift, 0, 100);
    motorForward(MOTOR_RIGHT, rightSpeed);
  }
  else motorReverse(MOTOR_RIGHT, 90);
  
  if ( (speed - drift)>0 )
  {
    int leftSpeed  =  constrain(speed - drift, 0, 100);
    motorForward(MOTOR_LEFT, leftSpeed);
  }
  else motorReverse(MOTOR_LEFT, 90);
}

Stefano descrive il suo sketch così:

il metodo usato da Margolis per seguire una linea curva consiste nel rallentare una ruota e accelerare l’altra per far curvare il robot. Ma se la curva è stretta il massimo che si può fare con questo criterio è tenere ferma una ruota e girare con l’altra. Quindi il raggio minimo teorico di una linea curva è la metà della distanza tra le ruote del robot (nel caso del mio è di circa 7 cm). Nella pratica il mio giocattolo aveva difficoltà sotto gli 11 cm nonostante io avessi ottimizzato lo sketch di Margolis togliendo e semplificando tutto il possibile in modo da renderlo più snello e reattivo.

Per migliorare il risultato, il mio algoritmo aggiunge la guida tipo cingolato che viene usata nei casi estremi. Cioè una ruota accelera e continua a girare in avanti, ma l’altra brevemente gira al contrario (a media velocità). Così il robot quasi gira su se stesso, e riesce facilmente a seguire ogni curva anche se di raggio minore dell’interasse delle ruote.

Il percorso che uso nel video è disegnato su un cartoncino di dimensioni 70 x 100 cm. La curva più larga ha raggio 14 cm e quella più stretta ha raggio 5 cm.

Come già detto uso solo due sensori per seguire la linea, e quindi nel caso di curva a L (a spigolo) il robot a volte fa fatica, effettua due rapide rotazioni da 45 gradi rischiando di perdere la linea. Bisognerebbe usare anche il terzo sensore, quello centrale, e in caso di rilievo contemporaneo del sensore centrale e un laterale si deve fare una rotazione su se stesso di 90 gradi.

Da notare che i sensori lavorano in analogico, così all’avvicinarsi della linea cominciano a variare la velocità dei due motori. Per rendere veloce la loro lettura (e quindi anche l’esecuzione dello sketch) ho aumentato la velocità del convertitore A/D di Arduino da 125 KHz a 1 MHz.

Leggendo lo sketch trovi subito alle linee 08-09 l’inclusione delle llibrerie ( http://examples.oreilly.com/0636920028024/Arduino-Controlled-Robot-Sample-Code.zip ) per il controllo dei motori, la prima è la libreria messa a disposizione dalla Adafruit e la seconda è stata scritta da Margolis ( autore del testo a cui si è ispirato Stefano per il suo progetto;

linea 11: definisci la variabile speed che incrementa la velocità dei motori;

linee 12-13: imposta i due pin analogici a cui sono connessi rispettivamente il sensore inseguitore di linea sinistro e destro;

linee 18-20: richiama le funzioni bitClear e bitSet per impostare la frequenza di conversione dell’ADC a 1Mhz come descritto da Stefano nella premessa;

linee 21-24: associa i due motori, sinistro e destro e li poni in stop;

linea 29: richiama la funzione lineSense() che vedremo nelle linee successive, ed assegna alla variabile drift il risultato dell’elaborazione eseguita;

linea 30: richiama la funzione lineFollow() passandole come primo parametro il drift e come secondo speed in modo che possa seguire la linea nera che individua il percorso;

linea 38: definisci la funzione di tipo integer denominata lineSense();

linee 40-41: leggi i valori analogici provenienti dai due sensori LEFT e RIGHT connessi ai pin analogici definiti alle linee 12-13;

linea 42: calcola il drift come differenza tra i due valori letti sui sensori di riflessione, questa operazione restituirà un drift positivo se il sensore LEFT restituisce un valore > del sensore RIGHT ed un valore negativo in caso contrario;

linea 43: restituisci il valore drift alla loop() che ha richiamato questa funzione;

linea 47: definisci la funzione che si occuperà di controllare i motori per inseguire la linea;

linea 49: verifica che la somma tra speed e drift sia positiva, questo comporta che il sensore LEFT restituisce un valore maggiore del valore di RIGHT oppure che RIGH supera di poco ( < 5 ) il valore di LEFT;

linea 51: limita il range dato dalla somma tra drift e speed ad un minimo di 0 ed un massimo di 100;

linea 52: applica la velocità al motore destro;

linea 54: in caso contrario, ossia con RIGHT nettamente maggiore di LEFT impone una velocità inversa al motore destro di 90;

linea 56: valuta la differenza tra speed e drift in modo che restituisca un valore positivo, questo si verifica se drift ha valore negativo, quindi se il valore del sensore RIGHT > LEFT;

linea 58: esegui il medesimo calcolo eseguito per la linea 51 applicandolo alla velocità del motore sinistro;

linea 59: applica la rotazione adeguata alla velocità calcolata al motre sinistro;

linea 61: in caso di differenza negativa tra speed e drift applichi al motore sinistro una contro rotazione del motore a velocità 90.

In conclusione Stefano propone due consigli che puoi applicare al robot segui linea:

1. la distanza da terra dei sensori per la linea è importante; fate delle prove visualizzando su serial monitor la lettura da pin analogico. Un millimetro in più o in meno fa molta differenza.
2. usate per il percorso un cartoncino molto opaco e un pennarello nero con pigmenti molto opachi nei confronti della luce all’infrarosso usata dai sensori.

Il video realizzato da Stefano