Porteføljeopgave 2

Robot: LAJ

Gruppemedlemmer: Jens Hesel, Lasse Hassel-Pflugh og Asger Nybo

 

Konkurrence Tid:

95,15 Sekunder

Video af testforsøg:

Sensor

Til at løse denne opgave er der anvendt i alt 3 sensor, 2 refleksionsensorer og 1 sonar sensor.

Refleksionsensor

De refleksionsensorer som er anvendt i dette projekt er en 3 benet sensor, et ben til ground, et ben til vcc og et til output. Refleksionssensoren indeholder en infrarød LED og en photosensor. Refleksionssensoren fungerer ved at den udsender et infrarødt lys og outputtet varierer ift. Hvor meget af dette som reflekteres tilbage på photosensoren. Denne egenskab kan blandt andet anvendes til at opnå informationer omkring farven på et underlag. I tilfældes hvor underlaget er mørkt vil lyset absorberes og refleksionen vil være svag. I tilfælde hvor underlaget er hvidt vil lyset ikke absorberes i samme grad og refleksionen vil være stærk. I dette projekt er refleksionssensoren anvendt til at navigere en Lego bil efter en sort linje på et gummilag, ved at placere begge sensorer under bilen.

Sonarsensor

Sonarsensoren anvender lydbølger til at bestemme afstanden til en genstand. Sonarsensoren udsender en lydbølge med en bestemt frekvens og ud fra den tid det tager før lydbølgen returnere til sensoren kan den beregne afstanden ved følgende formel:

Distance = varighed * lysets hastighed / 2

Det er vigtigt at bemærke, for at give sonarsensoreren de optimale forudsætninger, for at vurdere afstanden til genstand, så skal lydbølgen ramme vinkelret på en flad genstand. I projektet er sonarsensoren anvendt til at bestemme afstanden hen til Lego væggen, ved at placere sensoren forrest på bilen.

Opbygning af robot

Nedenstående billeder viser opbygningen robotten. De to reflektionssensorer sidder fastgjort med gaffatape under de to motorer, og sonarsensoren sidder fastgjort forrest på robotten også med gaffatape.

Tutorial til opbygning af robot

Nedenstående tutorial beskriver opbygningen af robotten. Se ovenstående billeder for yderligere vejledning.

  • Først bygges en bund af lange flade Lego klodser. Den skal være bred nok til et halvt breadboard, og lang nok til at et halvt breadboard og batterikasse til seks batterier kan ligge i forlængelse.
  • Herefter monteres Lego klodser rundt i kanten af rammen, så breadbord, Arduino og batterikasse ikke kan falde af.
  • Herefter monteres motorerne helt ude ved kanten i den ende, hvor breadboard og Arduino ligger.
  • Nu påsættes støttepinden i enden under batterikassen.
  • Derefter monteres sensorerne med gaffatape, og en elastisk sættes rundt om robotten for at holde på ledningerne.
  • Til sidst samles hardwaren som anvist i hardware-diagrammet.

Hardware-diagram

Som det fremgår af hardware diagrammet er der anvendt et motorshield til at styre motorerne.

IR sensorerne udsender infrarødt lys og alt efter hvor meget der reflekteres tilbage, giver den Arduinoen informationer omkring farven på underlaget. Dette anvendes til følge den sorte streg rundt på den førstedel af banen.

Sonarsensoren udsender en bestemt lydfrekvens og lytter efter lydbølger med samme frekvens. På den måde kan sensoren beregne afstanden til muren.

Opbygning af program

Programmet er opbygget således, at bilen starter med at følge den sorte streg, ved at tjekke med de infrarøde reflektionssensorer, om nogle af dem kan se den sort streg. Kan de det skal bilen dreje væk fra den sorte strej, ifht. sensoren. Hvis ingen af sensorerne kan se den sorte streg, kører bilen ligeud. Ultrasonic distance sensoren tjekker hele tiden om der er noget inden for 35cm. Hvis der er det, antages det at bilen har set væggen. Derefter igangsættes en række kommandoer til bilen som styrer bilen uden om muren. Styringen omkring muren er altså hardcodet.

 

Nedenstående flowdiagram viser robottens opførsel:

Den rå kode kan ses herunder.

// Initiating variables and pins for the sensors and motors

int sensorPinA4 = A4;// select the input pin for Reflection Sensor
int sensorPinA5 = A5; // select secound input pin for Reflection Sensor 2  
int RightSensor = 0; // variable to store the value coming from the right sensor 
int LeftSensor = 0; // variable to store the value coming from the left sensor 

// Pins for the Ultrasonic Distance Sensor
const int trigPin = A3;
const int echoPin = A2;

long duration;
int distance;

// Pins for the motors
int pwmA = 3;
int pwmB = 11;
int BrakeA = 9;
int BrakeB = 8;
int DirectionA = 12;
int DirectionB = 13;




void setup() 
{ 
Serial.begin(9600); //sets serial port for communication 
pinMode(DirectionA, OUTPUT); //Initiates Motor Channel A pin
pinMode(BrakeA, OUTPUT); //Initiates Brake Channel A pin
pinMode(DirectionB, OUTPUT); //Initiates Motor Channel B pin
pinMode(BrakeB, OUTPUT); //Initiates Brake Channel B pin
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input

digitalWrite(BrakeA, LOW); //Initiate the brake as Off
digitalWrite(BrakeB, LOW); //Initiate the brake as Off

} 


void loop() { 

RightSensor = analogRead(sensorPinA4); // read the value from the sensor
LeftSensor = analogRead(sensorPinA5); 

// Updates the distance from the Ultrasonic Distance Sensor
// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH);
// Calculating the distance
distance= duration*0.034/2;

// If-statement to keep the car on the black line
if ((RightSensor >= 750)&&(LeftSensor <= 750))
TurnRight();

else if ((RightSensor <= 750)&&(LeftSensor >= 750))
TurnLeft();

else
Forward();

//if-statement that calls a function to get the car around the wall, when it sees the car in front of it
if (distance < 35)
RundtOmVaeg();

else


}
// Function that turns the car left
void TurnLeft(void){
 digitalWrite(DirectionA, HIGH); //Establishes forward direction of Channel A
 analogWrite(pwmA, 230);   //Spins the motor on Channel A 

 digitalWrite(DirectionB, LOW); //Establishes backwards direction of Channel b
 analogWrite(pwmB, 130);   //Spins the motor on Channel b 
 delay(180);
}
// Function that turns the car right
void TurnRight(void){
 digitalWrite(DirectionA, LOW); //Establishes backwards direction of Channel A
 analogWrite(pwmA, 80);   //Spins the motor on Channel A 

 digitalWrite(DirectionB,HIGH);// Establishes forward direction of Channel b
 analogWrite(pwmB, 180);   //Spins the motor on Channel b 

 delay(130);
}
//Function that drives the car forward
void Forward(void){
 digitalWrite(DirectionA, HIGH); //Establishes forward direction of Channel A
 analogWrite(pwmA,105);  //Spins the motor on Channel A 

 digitalWrite(DirectionB, HIGH); //Establishes forward direction of Channel b
 analogWrite(pwmB,100); //Spins the motor on Channel b 
}
//Function that drives the car forward at a different speed
void Forward2(void){
 digitalWrite(DirectionA, HIGH); //Establishes forward direction of Channel A
 analogWrite(pwmA,250);  //Spins the motor on Channel A 

 digitalWrite(DirectionB, HIGH); //Establishes forward direction of Channel b
 analogWrite(pwmB,240); //Spins the motor on Channel b 
}
//Function to get the car around the wall
void RundtOmVaeg(void){
Forward();
delay(700);
// This whileloop makes sure the car turns enough regardless of how the angle was when it “saw” the wall
while (distance < 70){
TurnRight();
delay(620);
//Updates the Ultrasonic Distance Sensor
// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH);
// Calculating the distance
distance= duration*0.034/2;
}
Forward2();
delay(1500);
TurnLeft();
delay(800);
Forward();
delay(1500);
TurnLeft();
delay(750);
Forward2();
delay(4000);
digitalWrite(BrakeA, HIGH);
digitalWrite(BrakeB, HIGH);
}

Under kodningen blev der på et tidspunkt byttet om på højre og venstre funktionerne, og de bruges derfor omvendt.

Samspillet mellem mekanik, elektronik og software

Samspillet mellem elektronik og software er til dels tilfredsstillende ift. opgavebeskrivelsen. Funktionelt virker det efter hensigten, dog kunne opsætningen godt være mere stabil i form af kortere ledninger og bedre montering af breadbord og arduino på selve bilen. Det er valgt ikke at bruge gearing, derfor påvirker de to DC-motorer hjulene direkte, og da selve Lego konstruktionen er lille og let, giver det robotten mulighed for at accelerere hurtigt og opnå en høj hastighed.  

Konklusion

Robotten løser opgaven tilfredsstillende, dog er løsningen meget specifikt designet til øvebanen. Hvilket giver robotten nogle problemer, hvis den skal testes på en anden bane. Disse problemer indebærer den bagerste støttepind, der er meget følsom overfor friktion fra underlaget samt skidt i form af hår, sand osv. Støttepinden fungerer fint på øve banen, da den er slidt glat i overfladen, men der skal ikke meget skidt til før den får problemer med at dreje. Softwaren er også designet præcist til øvebanen, hvilket betyder der er opsat thresholds efter hvad sensorerne måler på øvebanen, dog kan disse thresholds hurtigt ændres og dermed tilpasses andre bane forhold.

Perspektivering

Der har ikke været meget fokus på design i opbygningen af robotten, hvilket er noget der kunne blive udviklet videre på. Det ville være optimalt at have et hjul bagerst der kan dreje 360 grader fremfor en støttepind, det var dog ikke muligt at finde et hjul der passede til.
Derudover kunne der godt blive gjort mere ift. Tilpasning af ledningernes længde samt montering og placering af arduino, breadbord og batterier på robotten.
Sidste del af banen rundt om muren er hardkodet, hvilket kræver at robotten kommer rigtigt ind på væggen for at komme igennem banen. Dette kunne være undgået ved at montere en sonarsensor på siden, som kunne måle afstanden ind til væggen, og dermed guide robotten rundt om væggen.

Leave a Reply