Af Thea Kingo og Sara Larsen

Guide til hvordan du bygger en autonom kørende Arduino LEGO robot.

Du skal bruge:

  • 1 Arduino-board
  • 2 LEGO motorer
  • 1 Motor-shield
  • 1 LEGO-køretøj, der kan bære det + batterier
  • Diverse sensorer

I den første del af programmet skal Lego robotten ved hjælp af Arduino-styringen kunne følge en sort streg på en lys bane, samt navigere rundt om en mur. For at navigere efter en sort streg skal der bruges lyssensorer til at registrere mellem sort og hvid. To lyssensorer placeres derfor forrest på robotten, med en afstand svarende til bredden af den sorte streg, så de ikke ser sort samtidig. Når robotten kommer til muren registreres muren ved at ramme den med en taktil knap som er placeret på robottens forreste spids. Knappen aktiverer anden del af programmet, hvor en afstandssensor til højre på robotten følger muren, afhængigt af afstanden til denne.

Tripple T vandt 3. pladsen med den bedste tid på  29 sek.
det er 3 sek efter 2. pladsen og 10 sek efter 1. pladsen.

Opbygning af robot i LEGO

Afsnittets formål er at vise hvordan LEGO motorerne og mekanik bygges ind i et LEGO-køretøj så hardware/elektronik kan integreres.

Følgende link indeholder en PDF med byggevejledning i LEGO

Download (PDF, 2.55MB)

Byggevejledningen indeholder hjælp til:

  1. Motorernes placering
  2. Tandhjul
  3. Hjulene og afstanden til gulvet
  4. Farvede klodser hvor der er mulighed for montering af sensorer

Hardwaren på robotten

I løbet af de følgende 5 trin kan opbygningen af kredsløbet til den tactile trunk følges. Foruden Arduino boardet, motor shieldet og de to motorer er anvendt:

  • 9V batteri (eller der tilsvarende)
  • 2 Infrarøde sensorer
  • 1 Sonar (afstandsmåler)
  • 1 Tactile swich (tryk knap)
  • 2 Strips, til fiksering af sensorer.

Flere af trinnene henviser til ledninger, som er loddet fast til komponenterne, eller fastsat vedhjælp af stik. Der henvises til at søge viden andre steder hvis der opstår problemer her i. De analoge og digitale pins numre som anvendes, kan altid vælges anderledes. Dette skal blot ændres i koden, se afsnittet nedenfor. I flere af trinene forklares sensorerne kort, hvorfor det kan være givende at læse, lige som placeringen gennemgås. Hvis disse trin ikke er vigtige, så følg blot tegningerne.

 

Trin 1: Batteri

Batteriet, som skal forsyne hele systemet, forbindes direkte til motor shieldets ene ende, ved at løsne skruerne i det blå element og placere de afisolerede ender i boardet. Vær opmærksom på at placere den røde ledning i positiv (VIN) og den sorte i den negative del (GND). Når batteriet er forbundet korrekte, bør der være lys på Arduino boardet. Se eventuelt figuren i Trin 2.

 

Trin 2: Motorer

Motorerne forbindes til motor shieldet, som batteriet (Trin 1). I det blå element på shieldet, er der plads til at i sætte en motor A og B. Hvordan ledninger isættes, har betydning for retningen af motorerne når disse i koden styres. Det kan derfor være en god ide, hvis muligt, at isætte ledninger ens; hvis der er farve forskel, så placer da én farve i + i henholdsvis A og B, og tilsvarende med -. Motorerne er integreret som vist i afsnittet ovenfor: 1. Motorenes placering. Motor A er i koden den højre motor, og motor B er den venstre. Dette kan simplet ændres i koden hvis de placeres anderledes.

 

 

Trin 3: Lyssensorer

I den første del af banen følger robotten en sort streg ved hjælp af lyssensorer. Lyssensorerne har tre ledninger: 1 rød til indgangsspænding, en sort til jord og en gul til at forbinde til boardet, således at input fra denne kan aflæses.

Disse lyssensorer består hver af to komponenter: en infrarød- sender og modtager. Senderen udsender hele tiden infrarødt lys, som reflekteres til modtageren, når lysstrålen rammer et objekt. Intensiteten af den reflekterede lysstråle afhænger af materiale og farve på det ramte objekt, og herved kan man bestemme om sensoren er placeret over den sorte eller hvide del af stofbanen. Lysmodtagerens modstand varierer efter lysintensiteten, hvorved en værdi mellem 0 og 1023 kan aflæses.

Før ledningerne forbindes i boardet, trækkes ledningerne igennem hullet på den røde LEGO klods som det ses i 4 Mulighed for sensor påsættelse, i afsnitte ovenfor. Lyssensorerne placeres under robotten, for at skærme for lys udefra, ligesom de placeres foran robottens hjulakse, for at muliggøre reaktioner på de fremadrettede ændringer i banen.

Der skal være en sensor på hver side af den mørke midterste klods (som ses af 4 Mulighed for sensor påsættelse), sådan at sensorerne sidder med cirka 1½ centimeters afstand, svarende til bredden på stregen som skal følges. Det kan være en fordel at fikserer sensorerne yderligere, med strips eller snor, for at sikre at de er ens vinklet i forhold til banen.

Ledningerne kan nu forbindes, således at de røde og sorte forbindes til henholdsvis +5V og GND. De gule ledninger er placeret i de analoge PINS 0 og 1 – hvilket opsættes i koden til at være et INPUT. I opbygningen er det valgt at pin 0 er venstre lyssensor, og pin 1 er højre. Dette kan selvfølgelig ændres let i koden.

 

Trin 4: Tactile knap

I det banens sorte streg stopper, skal robotten kunne følge muren rundt til banens ende. For at aktivere afstandsmåleren og deaktivere lyssensorerne, rammer robotten muren med en tactil swich (knap), placeres på robottens yderste spids, den grønne klods i: 4 Mulighed for sensorer påsættelse.

Til knappens ene ben skal en ledning loddes, som forbindes direkte til GND. Til knappens andet ben, skal to ledninger føres, en til +5V og den anden til en digital port, således at det kan aflæses om knappen er trykket. Ledninger til knappens to ben føres, som ved lyssensorerne, igennem den grønne klods, for at fikserer knappen. Ledningerne kan nu forbindes til boardet. Koden er sat op til at knappen forbindes til den digitale pin: 9.

 

Trin 5: Afstandsmåler

For at robotten det sidste stykke af banen kan følge muren, anvendes en afstandsmåler, en sonar.

Sonaren består af to elementer: en trigger, som udsender en lyd ved en bestemt bølgelængde, og et ekko, som modtager lyden. Det er tiden mellem triggeren har afsendt en lyd, til at ekkoet modtager denne, som afhænger af afstanden til det lyd-ramte objekt.

Sonaren har fire ledninger som skal forbindes. I afsnittet før er en gul klods placeret på robottens højre side, hvorpå sonaren kan placeres. Dette kan gøres ved at føre de to strips ind i gennem klodsen, og rundt ved sonarens midte. Sonaren er placeret på højre side lidt foran hjul aksen, da muren er på robottens højre side, og robotten lettere manøvrer rundt om muren når sonaren er placeret tæt ved hjulaksen.

Den røde ledning (VCC) forbindes til +V5, den sorte (GND) i GND på motor shieldet. De to resterende ledninger er henholdsvis Trigger og Ekko, og placeres i to digitale pins. Det er valgt at anvende port 6 og 7 til henholdsvis Ekko og Trigger.

 

Nedenfor ses hele kredsløbet med alle sensorerne forbundet til motor shieldet:

 

Programmet til robotten

Nu er robotten bygget og kredsløbet klar – det eneste som mangler nu er koden som beskrives i dette afsnit. Et flowdiagram viser koden, meget forsimplet i sin opbygning, og giver yderligere forklaring til hvordan robotten reagere på banen.

 

Den fulde kode ses nedenfor, hvortil yderligere kommentar er knyttet. Husk at ændre pins-numre, hvis sensorerne er placereret anderledes end beskrevet ovenfor. Ligeledes skal tresholdet, bestemmende for hvornår man ser sort og hvidt, muligvis ændres i forhold til det miljø robotten skal køre i. Dette gøres lettetest ved at uploade koden til robotten, og uden at fjerne USB strikket fra Arduinoen, placere robotten på banen. Herefter kan den Seriale Monitor åbnes, og værdierne kan aflæses. Det gælder om at vælge et treshold som ligger lige i mellem de værdier man får ved at placere robotten på den sorte og den hvide del af banen.

Hastighederne (speedFrem og speedDrej) kan med fordel justeres ned, for lettere at kunne se og følge robottens reaktioner til en start. I første del af programmet, drejer robotten ved at ændre retning på den ene motor, mens også hastigheden for denne sænkes. I anden del, drejer robotten ved at sætte hastigheden for det ene hjul til 0. Hastigheden beregnes som en funktion af afstanden til muren, hvilket kan ses i afsnittet: Samspillet mellem mekanik, elektronik og software. Så hvis hastigheden skal justeres i hele programmet, skal man være opmærksom på at ændre beregningen i anden del af koden.

Hvis robotten ikke kører som forventet, kan det være en mulighed at motorens ledninger er placeret anderledes, således at frem (HIGH) i koden, bør være LOW for den nye opbygning. Dette kan enten ændres i koden, men endnu lettere kan dette ændres ved at skrue ledningerne fra motoren ud fra det blå element på motor shieldet og bytte disse om (mellem + og -).

//Variabler

  const int sensorPin1 = 0;                                 // Venstre IR-sensor1 på pind A0
  const int sensorPin2 = 1;                                 // Højre IR-sensor2 på pind A1
  int Sensor1 = 0;                                          // Sensor1 hvor input fra sensorPin1 (højre) gemmes 
  int Sensor2 = 0;                                          // Sensor2 hvor input fra sensorPin2 (venstre) gemmes
  int threshold = 800;                                      // Værdien der skelner mellem hvid og sort
  int motorTurnA = 12;                                      // Digital pin 12 til styring af motordrejningen1
  int motorSpeedA = 3;                                      // Analog pin 3 til styring af motorhastigheden1
  int motorTurnB = 13;                                      // Digital pin 13 til styring af motordrejningen2
  int motorSpeedB = 11;                                     // Analog pin 11 til styring afmotorhastigheden2
  int speedFrem = 100;                                      // Hastigheden, når hjulet kører frem 
  int speedDrej = 15;                                       // Hastigheden, nåt hjulet kører tilbage (i et drej) 
  int afstand = 0;                                          // I denne variabel gemmen den målte afstand 
  int SAfstandEkko = 7;                                     // Digital pin 7 til sensor afstandsmålerens ekko (input lyd)
  int SAfstandTrigger = 6;                                  // Digital pin 6 til sensor afstandsmålerens trigger (output lyd)
  int e = 0;                                                // Variablen bruges som tæller til at dreje når muren rammes

void setup() {

  Serial.begin(9600);                                       // Gør det muligt at udskrive data på computeren

  //Opsætning af porte for afstandmåler
  pinMode(SAfstandTrigger, OUTPUT);                         //Den digitale pin SAfstandTrigger sættes til output (lyd output) 
  pinMode(SAfstandEkko, INPUT);                             //Den digitale pin SAstandEkko sættes til input (lyd input) 

  //Opsætning af porte for motorer 
  pinMode(motorTurnA, OUTPUT);                              // Erklærer at motorTurn er output
  pinMode(motorSpeedA, OUTPUT);                             // Erklærer at motorSpeed er output
  pinMode(motorTurnB, OUTPUT);                              // Erklærer at motorTurn er output
  pinMode(motorSpeedB, OUTPUT);                             // Erklærer at motorSpeed er output

}

void FindAfstand(){                                         // Funktion som kaldes når afstanden skal findes 

  //Lyd udsendes (trigger) og lyden optages (ekko) 
  digitalWrite(SAfstandTrigger, LOW);                       // Lyd outputtet stoppes
  delay(2);
  digitalWrite(SAfstandTrigger, HIGH);                      // Lyd outputtet startes 
  delay(10);                                                // Lyd outputtet er tændt i 10 milisekunder 
  digitalWrite(SAfstandTrigger, LOW);                       // Lyd outputtte stoppes
  
  //Afstanden bestemmes 
  afstand = pulseIn(SAfstandEkko, HIGH);                    //pulseIn funktionen henter inputtet fra Ekko porten 
  afstand = (afstand/2)/29.1;                               //Inputtet (aftsand) omregnes til centimeter

  //Udskriv afstanden 
  Serial.println("afstand:");             
  Serial.println(afstand);
  Serial.print("       KnapTilstand:  ");       
  Serial.println(digitalRead(9));                           //Knappens tilstand aflæses, 1 = kører efter en streg, 0 = kører efter muren 
}

void loop() {

  // *******************************************************************************************************************************************
  // ********************************************************************* DEL 1 ***************************************************************
  // *************************************************************** KØRER EFTER LINJEN ********************************************************
  // *******************************************************************************************************************************************
  
  //Aflæser input for lyssensor 
  Sensor1 = analogRead(sensorPin1);                         // Læser værdien fra IR-sensor1 (højre)
  Sensor2 = analogRead(sensorPin2);                         // Læser værdien fra IR-sensor2 (venstre)
  
  //Printer lyssensor input 
  Serial.print(Sensor2); // venstre
  Serial.print(", ");
  Serial.print(Sensor1); // højre
  Serial.print(", ");
  Serial.print("       KnapTilstand:  ");
  Serial.println(digitalRead(9));                           // Knappens tilstand aflæses, 1 = kører efter en streg, 0 = kører efter muren
  
  //Styring af motorer afhængigt af lyssensor input 
  if (Sensor1<threshold && Sensor2>threshold) {             // Sensor1 ser hvid og Sensor2 (venstre) ser sort - drej til venstre 
    digitalWrite(motorTurnA, HIGH);   
    analogWrite(motorSpeedA, speedFrem);
    digitalWrite(motorTurnB, LOW); 
    analogWrite(motorSpeedB, speedDrej);
    }
  else if (Sensor1>threshold && Sensor2<threshold) {        // Sensor2 ser hvid og Sensor1 (højre) ser sort - drej til højre
    digitalWrite(motorTurnA, LOW);
    analogWrite(motorSpeedA, speedDrej);
    digitalWrite(motorTurnB, HIGH);
    analogWrite(motorSpeedB, speedFrem);
    }
  
  else{
    digitalWrite(motorTurnA, HIGH);
    analogWrite(motorSpeedA, speedFrem);
    digitalWrite(motorTurnB, HIGH); 
    analogWrite(motorSpeedB, speedFrem);
    }

  // *******************************************************************************************************************************************
  // ********************************************************************* DEL 2 ***************************************************************
  // *************************************************************** KØRER EFTER MUREN *********************************************************
  // *******************************************************************************************************************************************
  
  if(digitalRead(9) == 0){                                  // Knappens tilstand aflæses, 0: kører efter muren
  speedFrem =60;
    //Bakker væk fra muren
    while(e<80){;                                           //Så længe e er mindre end 100 - bakker robotten væk fra muren 
      digitalWrite(motorTurnA, LOW); 
      analogWrite(motorSpeedA, speedFrem);
      digitalWrite(motorTurnB, LOW); 
      analogWrite(motorSpeedB, speedFrem);
      e++;
      Serial.println("Drejer");
    }

    //Drejer væk fra muren, således vil aftandsmåleren herefter pege mod muren
    while(e<280){;                                          //Så længe e er mindre end 300 - drejer robotten til venstre
      digitalWrite(motorTurnA, HIGH); 
      analogWrite(motorSpeedA, speedFrem);
      digitalWrite(motorTurnB, LOW);
      analogWrite(motorSpeedB, speedDrej);
      e++;
      Serial.println("Drejer");
    }

    //Resten af tiden
    while(true){                                            // While vil altid være true indtil arduinonen genstartes 
      FindAfstand();                                        // Funktionen FindAfstand() kaldes (se tidligere i koden) 
  
      // Styring af motorer på baggrund af input fra afstandsmåleren 
      if(afstand > 10){                                     // Afstanden til muren er større end 10, så robotten drejer til højre (ind mod muren) 
        speedFrem = (6-afstand)*10;
        digitalWrite(motorTurnA, HIGH);
        analogWrite(motorSpeedA, 0);
        digitalWrite(motorTurnB, HIGH);
        analogWrite(motorSpeedB, speedFrem);
      }
      else if(afstand < 6){                                 // Afstanden til muren er mindre end 5, så robotten drejer til venstre (væk fra muren)  
        speedFrem = (afstand-10)*10;
        digitalWrite(motorTurnA, HIGH); 
        analogWrite(motorSpeedA, speedFrem);
        digitalWrite(motorTurnB, LOW); 
        analogWrite(motorSpeedB, 0);
      }
      else{                                                  // Ellers: aftsanden er mellem 6 o 10 centimeter, robotten kører lige ud  
        digitalWrite(motorTurnA, HIGH);
        analogWrite(motorSpeedA, speedFrem);
        digitalWrite(motorTurnB, HIGH);
        analogWrite(motorSpeedB, speedFrem);
        speedFrem = 60;
      }
    }
  }
}

 

Samspillet mellem mekanik, elektronik og software

Sensorerne som er en del af robottens elektronik, giver data til softwaren, der får de mekaniske motorer til at køre på en given måde.
I første del af softwaren kører robotten som standard ligeud – det gælder når begge lyssensorer ser hvid, hvilket er defineret af softwaren. Ser højre lyssensor sort, så drejer den mod højre ved at højre hjul kører lidt bagud mens venstre hjul kører fremad. På samme måde med venstre. Når hjulene bevæger sig hver sin vej, drejer robotten. Dette er forsøgt illustreret nedenfor, hvor begge lyssensor for robotten til venstre er placeret over banens hvide farve, og den derfor kører ligeud. Når banen drejer sig, rammer den ene lyssensor på robotten til højre den sort streg, hvilket gør at robotten drejer mod højre, hvor igen begge sensorer vil være placeret ovenfor banen hvide del.

Når den taktile switch bliver aktiveret, ved at robotten køre ind i muren, så aktiveres anden del af softwaren. Her bliver input fra lyssensorerne ikke læst, men det gør input fra afstandssensoren.

Afstandssensorens input omregnes til centimeter, for lettere at kunne definere et afstands threshold som skal holdes til muren. Når afstanden bliver større end thresholdet, større end 10 centimeter, kører robotten ind mod muren, for igen at opnå den rette afstand. Ligeledes kører robotten væk fra muren, hvis afstanden bliver for lille, mindre end 6 centimeter. På den måde kører robotten rundt om enden på muren og i mål. I anden del af programmet, afhænger afstanden robotten kører i, af afstanden til muren. Således vil en afstand på 5 centimeter, forårsage en lav hastighed når robotten drejer væk fra muren, hvorimod en afstand på 1 centimeter, vil give robotten en øget hastighed til at dreje væk. Dette gælder også når robotten er længere væk end 10 centimeter. Robotten kører frem, med samme hastighed på begge hjul når afstanden er mellem 6 og 10 centimeter. Beregningerne af hastigheden ses af koden samt nedenfor:

På den måde gøres robotten mere intelligent, da den nu kan variere sin hastighed efter omgivelserne. Dette er gjort, da robotten har haft store problemer med at dreje om muren, i det denne ender. Muren blev for det meste ramt, fordi afstandsmåleren ramte skævt på muren og fik en højere afstand end den egentlige. Ved at ændre hastigheden, til en dynamisk størrelse afhængig af afstanden, gennemfører robotten langt oftere hele banen.

Refleksion

Dette afsnit er en udvidelse til den oprindelige opgave formulering, for at opfylde Hardware og Robotter kursusbeskrivelsen for kandidat studerende, Thea Kingo.

Det kan i mange sammenhænge være aktuelt for en kørende robot, at kende sin placering, enten i forhold til den veldefinerede bane, som i første del af opgaven, eller til objekter i dennes miljø. Robotten i opgaven, er en udelukkende online robot, betydende at den er kodet således at den følger en streg når den under de rigtige forhold placeres på denne, og at den kan følge, en aktuelt mødt mur. Den har ikke før start, offline fasen, bestemt en rute eller nogen viden om banen der skal fuldføres. Robottens viden om banen er faktisk ikke eksisterende, da den ikke lagere tidligere input, og derfor er der ingen mulighed for at mappe, altså at kortlægge, banen til senere brug.

For at give robotten flere input om sin kontekst, kunne man have anvendt en sonar, som roterer om sin egen akse, for på den måde at opsamle informationer om et større område. Disse informationer, vil blive givet som punkter, altså afstande til omgivelserne ved en bestemt vinkling i rotationen og placeringen af robotten. Herved kan en mur bestemmes – ved metoder som under et kaldes Feature Extraction. Metoderne dækker blandt andet over Incremental, RANSAC og Hough. Fælles for dem alle er at punkterne, altså afstandene skal være kendte, hvorefter metoderne adskiller sig. Incremental forbinder to nærliggende punkter, hvortil hældningen for stregen mellem disse beregnes. Yderligere punkter tilføres nu, og det testes så løbende om de nye punkter ligger i forlængelse af de første, altså at de udspænder en linje; en linje med samme hældning. RANSAC derimod vælger to tilfældige punkter af alle de kendte og forbinder disse to. Afstanden fra stregen, som kan tegnes mellem de to punkter, og alle andre punkter beregnes. Punkter, som ligger tæt på stregen er de såkaldte inliers og hvis der er nok af disse, fjernes punkterne og i stedet står kun stregen tilbage. For begge disse metoder gælder at en masse thresholds må opsættes, og resultatet afhænger af disse. For eksempel hvor meget hældningen må variere, ved hvilken afstand et punkt ikke længere er en inlier og hvor mange punkter der skal være inliers før stregen godtages. Hough metoden adskiller sig meget fra de to foregående. I Hough metoden vælges et sæt af punkter, hvor fra gennemløbende midlertidige streger tegnes ved hver, med samme vinkling til det globale koordinatsystem. Afstanden fra 0,0 til stregerne ved én bestemt vinkling, indtegnes i et koordinatsystem, efterfulgt af afstandene til den næste vinkling. Ved den vinkling hvor alle, eller tilnærmelsesvis alle, punkterne mødes – altså har samme afstand ved samme vinkling i forhold til det globale 0,0, er stregen som forbinder punkterne. Så ved hjælp af en roterende sonar, og en Feature extraction metode, vil man kunne opsamle afstande til objekter, hvortil metoderne vil kunne finde linjer i miljøet som kunne følges, eller blive starten på et kort over området.

Der er meget velfærdsteknologisk udstyr, som har behov for at kende sin egen placering i forhold til omgivelserne, her i blandt den omdiskuterede robotstøvsuger eller den lidt mere ukendte LEA, den motorstyrede rollator. Robot støvsugeren, eller den selvkørende støvsuger, som mange kalder den, kan styres på mange forskellige måder. Billigst er nok den tilfældige styring, hvor støvsugeren ikke ved hvor den har været, eller hvor den kommer fra, men blot kører lige ud, indtil et objekt mødes. Med en veldefineret afstand til objektet, således at støvet fjernes tæt på paneler og andet, drejer støvsugeren i en tilfældig ny retning, og fortsætter således i en forudbestemt tid. Robotten bygget til opgaven her, har sådan set det der skal til for at gøre dette. Sonaren på siden, må flyttes til spidsen, og koden skrives om. Koden må styrer robotten således at bliver afstanden mindre end det tilladte til et objekt, drejer robotten i en random-udvalgt tid. De mere avancerede støvsugere kører rundt og sonderer miljøet, for herved at kortlægge omgivelserne, og med en forudbestemt metode bestemmer de herefter ruten. Dette gælder for eksempel Samsungs VR9000, som, blandt mange sensorer, har et kamera placeres på den vandrette øverste del. Kameraet hjælper VR9000 med at kortlægge hele rum, hvorefter den bestemmer en rute rundt i rummene. Dens ruter krydser hinanden minimalt, og kunne være opbygget ved en metode som Canny. Dog anvendes Canny oftest når der er flere objekter på et område, hvilket nemlig definere de blevne kontourer, efter Cannys swipline har gennemløbet hele billedet. Kontourene går fra kritiske punkter, fx den yderste kant af objekter, til det yderste af billedet. På den måde inddeler Canny metoden es områder i mindre dele, kaldet celler. I en celle, kan man i direkte linje, nå hvert et område af hele cellen. En celle kan derfor i et simpelt mønster blive gennemkørt af robotstøvsugeren, hvortil kun overgangen mellem cellerne skal defineres yderligere.

Robotten bygget til denne opgave, er bygget kun med det for øje at løse den aktuelle bane i lyset fra laboratoriets svage lamper. Robotten kan ikke følge andre typer af streger, vil ikke kunne følge en mur medmindre knappen trykkes, og vil herefter kun følge muren, uden at tage højde for en eventuel ny streg. Robotten vil aldrig vide hvor den er, andet end om den lige i dette øjeblik ser stregen, eller sensor muren. Hvis man satte robotten i et andet miljø, vil den kunne følge en mur. Robotten vil følge muren, men kun indtil et skrapt hjørne, hvorved knappen vil blive trykket ned, og robotten, som aldrig bakker, vil sidde fast. Den er altså meget lidt anvendelig i andre omgivelser end de i opgaven givet, og det er netop fordi den ikke er intelligent eller har en yderligere bevidsthed om sin kontekst.

Konklusion

Robotten kan gennemføre banen ved at køre efter den sorte streg, på det lyse underlag, ved hjælp af to lyssensorer placeret på hver side af den sorte streg. Robotten rammer muren, med sin spids hvorpå en knap er monteret. Her efter følger robotten muren ved hjælp af en afstandsmåler.

Robotten har nogle gange problemer med at dreje omkring muren, men resten af banen giver ingen problemer.

Perspektivering

Robotten har som nævnt problemer med at følge muren, når muren ender. Da banens størrelse og udformning er fast, kunne man have styret robotten uden afstandsmåleren. Ved at forsøge sig frem, kunne man have bestemt hvor længe robotten skulle kører frem eller dreje for at nå banens slutmål. På den måde kunne man spare afstandsmåleren, og derved fjerne risikoen for at denne registrer afstanden til muren forkert. Det kan dog være svært at sikre at ruten som laves, vil få robotten sikkert i mål, da placeringen af robotten, efter at have fulgt den sorte linje vil variere.

Leave a Reply