Af: Camilla og Tobias

Slowdriver5000

I denne portefølje, skulle vi konstruere en autonom kørende Arduino LEGO robot, der ved hjælp af sensorer skulle kunne følge en bane fra A til B. Robotten skulle kunne gennemføre banen på max. 3 minutter.

 

På billedet kan man se, hvordan banen ser ud.

 

Skærmbillede 2016-05-10 kl. 19.43.45

Robottens bedste tid: 64 sek.

Se bilen køre her https://www.youtube.com/watch?v=7WNNOD4sxTo
 

Opbygning af hardware i fritzing

 Skærmbillede 2016-04-27 17.03.39

 

På denne fritz tegning, kan man se elektronikkens sammensætning, og hvordan de forskellige komponenter er tilsluttet til vores Arduino motor shield, og derved udgør robottens hjerne.

Det skal siges, at de sensorer der er tilsluttet på tegningen, ikke er dem vi brugte i vores robot, men nogle der ligner til forveksling. Dette har vi valgt at gøre, da de sensorer vi brugte (line sensors) ikke findes i fritzing programmet, dette gælder også for DC motorerne vi har brugt på tegningen, som oprindeligt er lego DC motorer.

For at få robotten til at køre sætte vi vores to lego DC motorer til hver deres indgange A og B. Dernæst tilslutter vi batterierne, så der er strøm til boardet. Herefter tilføjes sensorerne til hver deres analog port, derefter strømforsyning og ground.

Opbygning af robot i lego (Billeder)

thumbnail_IMG_8201 thumbnail_IMG_8202 thumbnail_IMG_8203 thumbnail_IMG_8204

Vi startede med at tage udgangspunkt i form af en plade, som vores arduino motor shiels og batterier kunne stå på, dog blev vi nødt til at tilføje en ekstra længe på pladen, da den ikke var stor nok.
Under vores plader har vi valgt at stabilisere robotten, således at vi fik en mere robust fundament. Vi valgte at bruge et støtteben, da det var den simpleste og mest effektive måde at få vores robot til at dreje på. Ved siden at vores støtteben har vi valgt at montere vores sensorer, dette skyldes at sensorerne måler refleksion af lys og har derfor brug for at komme så tæt på underlaget, som overhovedet muligt. Hvis ikke de er tæt på underlaget så er der ingen lys der bliver reflekteret.

Samtidig har vi lavet en lille ekstra boks, udenom således at vi lukker unødig sollys ude. Lige over støttebenet har vi sat en holder, som er til for at holde batterierne på plads.

Vi har fastmonteret arduinoen, ved hjælp af fire klodser og en stang. Hjulene er monteret lige ved motorerne og er blevet bygget med en gearing således at robotten har mere kontrol. Vores gearing nedsætter nemlig vores robots hastighed.

(8/40) =1 : 0,2

Altså bliver vores hastighed nedsat med 80%

Opbygning af program

int sensor1 = 2;
int sensor2 = 3;

bool stopStep(){
  digitalWrite(12, LOW); 
  analogWrite(3, 0);
  digitalWrite(13, HIGH); 
  analogWrite(11, 0);
}
bool firstStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 200);
        digitalWrite(13, HIGH); 
        analogWrite(11, 200);
      }
bool secondStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 200);
        digitalWrite(13, HIGH); 
        analogWrite(11, 0);
      }
bool thirdStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 200);
        digitalWrite(13, HIGH); 
        analogWrite(11, 200);
      }

      bool fourthStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 0);
        digitalWrite(13, HIGH); 
        analogWrite(11, 200);
      }

      bool fifthStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 200);
        digitalWrite(13, HIGH); 
        analogWrite(11, 200);
      }

      bool sixthStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 0);
        digitalWrite(13, HIGH); 
        analogWrite(11, 200);
      }

      bool seventhStep(){
        digitalWrite(12, LOW); 
        analogWrite(3, 200);
        digitalWrite(13, HIGH); 
        analogWrite(11, 200);
      }
void setup() {
 
  //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A pin
  pinMode(9, OUTPUT); //Initiates Brake Channel A pin
  pinMode(13, OUTPUT); //Initiates Motor Channel A pin
  pinMode(8, OUTPUT);
  
  Serial.begin(9600);
  
}

void loop(){ 
      int sensor1value = analogRead(sensor1);
      int sensor2value = analogRead(sensor2);
      int rate1 = map(sensor1value, 0, 1023, 0, 100); 
      int rate2 = map(sensor2value, 0, 1023, 0, 100);
      Serial.println(rate1);
      Serial.println(rate2);
      int dif = rate1 - rate2;
      if(dif < -20){
        digitalWrite(12, HIGH); 
        analogWrite(3, 0);
        digitalWrite(13, HIGH); 
        analogWrite(11, 100);
        Serial.println(dif);
      }
      else if(dif > 20 ){
        digitalWrite(12, LOW); 
        analogWrite(3, 100);
        digitalWrite(13, LOW); 
        analogWrite(11, 0);
      }
      else{
        digitalWrite(12, LOW); 
        analogWrite(3, 100);
        digitalWrite(13, HIGH); 
        analogWrite(11, 100);
      }
      if(sensor1value > 800 && sensor2value > 800) {
    while (stopStep()){
      delay(1000);
      break;    
    }
    while (firstStep()){
      delay(2200);
      break;
    }
    while (secondStep()){
      delay(3700);
      break;}
    while (thirdStep()){
      delay(6100);
      break;
    }
    while (fourthStep()){
      delay(3800);
      break;
    }

    while (fifthStep()){
      delay(1500);
      break;
    }

    while (sixthStep()){
      delay(3400);
      break;
    }
    while (seventhStep()){ 
    }
      }
     
  }

Programmet der styrer vores program er opbygget på en simpel men effektiv måde. Vha. De to sensorer, som vi har sat foran på vores robot, kan robotten registrere hvorvidt den er ved at køre uden for den sorte streg eller ej.
De to sensorer måler værdier alt efter hvilken farve underlag den køre på, jo mørkere underlag, jo højere værdi. Hver sensor opfanger en værdi, og hvis differencen mellem de to sensorers værdier er for stor, så ved robotten at den skal dreje, enten til venstre eller til højre.
Værdien som de to sensorer måler, regner vi om til procent, da det er nemmere at arbejde med, dette gøres vha. Map funktionen.

Når robotten når til det punkt på banen, hvor den sorte streg ophører, bliver det mere interessant.
Vi skal nu navigere rundt uden, den sorte streg. Foran os er der en mur der skal navigeres rundt om, til dette er der flere muligheder, man kan f.eks. gøre brug af endnu en sensor, det kan registrere om der er et objekt foran/på siden af robotten.
Vi valgte derimod at hardcode vores robot. Så robotten ved ikke der er en mur foran, den følger bare instrukser om køre en bestemt rute.

Vi skulle først have robotten til at stoppe ved den sorte linjes ophør, hvor der var tegnet en sort streg vinkelret på den oprindelige sorte linje.
For at få robotten til at stoppe, har vi lavet en if-sætning der siger, at hvis begge sensorer måler en værdi på over 800, så skal den stoppe. Dette kan gøres, da vi ved at jo mørkere et underlag robotten kører på, jo højere en værdi vil sensorerne anslå.
Under denne if-sætning, finder vi også vores hardcoding af robottens sidste rute. Den er lavet på den måde at så snart if sætningen er sand, så har vi en række while loops, hvori vi finder vores funktioner. Disse funktioner fortæller robotten hvordan den skal navigere. Så snart en funktion bliver kaldt, så har vi et delay, alt efter hvor længe det er nødvendigt at denne funktion kører, herefter bruger vi ”break” funktionen, som hopper ud af while loopet, og dermed starter det næste while loop, og dermed også den næste funktion. På den måde klarer robotten sig igennem banen.

Samspillet mellem mekanik, elektronik og software

1. Softwaren starter processen, og giver hardwaren besked om et ønskede signal.

2. Hardwaren “danner indtryk” af miljøet og der sendes et signal.

3. Signalet bliver behandlet af softwaren, og der bliver derefter afgjort, hvad det næste skridt skal være.

4. Hardwaren “lytter” til softwarens signal, og dette ændre mekanikken i robotten.

Konklusion:

Vi løser opgaven på en meget god og langsom måde, den opfylder alle kravene. Den kan gennemøre banen på den krævende tid, hvilket er på mindre end 3 minutter. Samtidig undgår vi de røde linjer, som ellers ville have givet straf point til vores endelige tid, og til sidst, så undgår vi at køre ind i den sidste forhindring, muren, og navigere fint rundt om, for til sidst at vælte objektet på målstregen.

 

Perspektivering:

I stedet for at hardcode vores robot til den sidste del, kunne vi have brugt en sensor, som kunne registrere om der var en mur foran den, og så navigere rundt om denne, vha. Denne sensor. At tilføje en sensor, ville også have gjort vores robot mere tilregnelig, da hardcoding hurtigt går hen og bliver meget utilregneligt, dette skyldes, at man løbende bruger strømmen på batteriet, og vil hastigheden på robotten ændre sig. Det gør også arbejdet større, da man konstant bliver nødt til at ændre og tilpasse koden alt efter det strøm niveau der er på batterierne.

Vi  valgte at hardcode vores robot og på den måde navigere rundt om muren.
Hvis vi skulle have forbedret vores robots tid, og få den til at gennemføre banen endnu hurtigere, kunne dette blive gjort vha. ekstra gearing på robotten. På nuværende tidspunkt har vi kun gearing der sænker hastigheden på robotten så den kørte mere kontrolleret.

Leave a Reply