Formål:

Formålet med denne opgave var at konstruere en autonom robot. Robotten havde til formål at skulle køre en prædefineret route med forhindringer. Til at bygge robotten fik vi udleveret et Arduino-board, et Motor Shield, to motorer, diverse sensorer og LEGO.

Navn: HvemStjalVoresBatterier?

Gruppe 4: Andreas Grøntved Jeppesen, Martin René Jakobsen, Rasmus Gorm Petersen, Rasmus Reinholt Mørch Jørgensen

Billede af robotten

rsz_img_1206.jpgrsz_img_1208.jpg

 

Diagramtegning

portefølje1Sketch_bb.png

Forklaring af valg af modstande

Under forløbet har vi brugt 2 forskellige sensorer, CNY70(Lysmåler) og SRF02(afstandsmåler). Begge sensorer kan klare en bestemt mængde spænding for at fungere. Derfor benyttes modstande til at tage sig af den overflødige spænding og derved sørge for at der ikke går for meget igennem og ødelægger sensorerne.

Modstanden er beregnet ved Ohms lov og værdierne fra sensorernes datakataloger.

Ohms lov: U  =  I  *  R     =>  R  =  U  /  I

Når vi omskriver Ohms lov og indsætter vores egne værdier kan vi finde frem til hvilke modstand vi skal bruge. Her indsætter vi U = (Vss – Vf) hvor Vss er den spænding arduinoen sender ud til at starte med og Vf er den spænding som sensoren skal bruge. If er den strøm(målt i ampere) som sensorerne kan tåle.

Nu indsætter vi de kendte værdier og udregner modstanden.

Vss  =  5V            Vf  =  1,6V            If  =  0,05A

R  =  (5V  –  1,6V) / 0,05A  =  68

68 er grænseværdien for sensoren, så hvis vi bruger en modstand lavere end 68 går sensoren i stykker. Vi  valgte derfor at bruge en modstand på 75.

Robotten

Hvordan er robotten opbygget i forhold til at løse opgaven

Robotten har 1 til 3 gearing (lille tandhjul på motor og stort på hjul), dette er gjort for at robotten har mere kraft til at køre (så robotten ikke går i stå, når der er bare den mindste modstand, som fx når den svinger). Robotten har larvefødder fordi det var vores vurdering, at det at lave robotten med hjul ville gøre at et evt for-eller baghjul ville kunne give problemer med at stå forkert, når robotten skulle dreje.

Hjulene der trækker larvefødderne er valgt ud fra deres greb om båndet, mens valg af bånd var begrænset pga. udvalg. Robotten har 2 lyssensorer. Det var oprindeligt tænkt at den skulle have 3 lyssensorer. Med den tredje lyssensor ville det være muligt for robotten at finde ud af, hvornår det ville være mest optimalt at stoppe at dreje, så den efterfølgende kunne køre ligeud. Med 2 lyssensorer zigzagger robotten, som ville være et problem, hvis stykket uden streg var længere.

Grundet at vi har brugt Motor Shield for at kunne levere nok spænding til motorerne, var det dog ikke muligt at bruge den 3. lyssensorer, da Motor Shieldet bruger 2 af de analoge porte.

Lyssensorerne sidder på hver sin side af stregen – med en smule afstand til stregen, for at de ikke skulle komme til at ramme stregen hele tiden.

Ultralydssensoren sidder foran, rettet så lige ud som muligt, så den kommer til at måle afstanden til forhindringen og ikke fx gulvet. Ultralydssensoren virker ved at sende lyd ud, og ud fra hvor lang tid det tager lyden at komme tilbage, kan den vurdere afstanden til et objekt.

Billede af robotten og forklaring af konstruktionrobotForklaring.jpg

Hver kasse på billedet til højre har et tilsvarende punkt herunder.

1. Batterier, placeret øverst for at gøre det nemmere at tilslutte strøm/tage det fra igen.

2. Arduino og Motor Shield, samt breadboard, dervidereførerr forbindelserne

3. Her peger Afstands sensoren frem, mens de to lyssensorer peger ned.

4. Til vores robot har vi valgt at bruge larvefødder som kører rundt ved hjælp af gearing.

Robottens opførsel

Robotten arbejder med disse overordnede tilstande:

  • turboMode

  • klodsMode

  • Kryds

  • Venstresving

  • Højresving

turboMode aktiveres før første kryds og efter sidste kryds. Før første kryds kører robotten maksimal hastighed og efter sidste kryds kører robotten lidt hurtigere end normal hastighed.

klodsMode aktiveres når robotten kommer indenfor 5 inches af klodsen. Når klodsMode er aktiveret kører robotten en forudprogrammeret rute, og når højre sensor rammer stregen igen, går robotten tilbage til normal opførsel.

Kryds er når begge sensorer ser en streg, hvis dette er tilfældet, kører robotten lige ud, dette er nødvendigt fordi robotten ellers ville stå og køre venstre og højre foran stregen indtil den når forbi eller køre til venstre eller højre (som den ikke må!!!).

Højre- og venstresving sker når kun en af lyssensorerne ser en streg.

Flow diagram for opførsel

Kode

#include <Wire.h>

int readpin1 = A2;
int readpin3 = A3;

int Irpin = 2;

int maxStreg = 500;
int minStreg = 900;  
int klodsAfstand = 5;

int lys1 = -1;
int lys3 = -1;

int afstand = -1;
int speedUpTime = 1300;
int speedUp = 0;
int timer = 0;
int minSpeed = 75;
int maxSpeed = 255;
int botSpeed = 150;
boolean turboMode = true;
boolean speedUpCross =true;

int reading = 0; //Afstand 

void setup ()
{
	Wire.begin(); //Afstand

	Serial.begin (9600);
	pinMode (Irpin, OUTPUT);

	//MOTOR 1 Setup Channel A
	pinMode(12, OUTPUT);
	pinMode(9, OUTPUT);

	//MOTOR 2 Motor channel B
	pinMode(13, OUTPUT);
	pinMode(8, OUTPUT); 
}

void loop ()
{  
	//Før første kryds er der ikke nogle skarpe sving
	//og robotten kan derfor sikkert køre maks hastighed
	//indtil den støder på første kryds - det samme gælder
	//for efter sidste kryds	
	if(turboMode == true ){
		botSpeed = maxSpeed;
	} 
	else {
		botSpeed = 100;
	}

	lys1= printLight(readpin1);
	lys3= printLight(readpin3);
	afstand = getDistance();
	int left = botSpeed;
	int right = botSpeed;

	//Afstandssensoren giver en gang imellem værdien 0
	//for at undgå at dette bliver et problem gøres variablen
	//"afstand" ubetydelig (når den er under 2) i forhold til at 
	//bedømme om robotten skal i klodsMode
	if(afstand == 0){
		afstand = klodsAfstand +10;
	}

	//Hvis der er en klods foran robotten går den i klodsMode
	//Klodsmode er en på forhånd defineret rute uden om klodsen
	if(afstand<klodsAfstand){
		//Klods er farligt tæt på
		klodsMode();
		speedUpCross = true;
	} 
	else {
		if(lys1 < minStreg &&  lys3 < minStreg){
			//Robotten er ved et kryds!!!
			//Her sørges for, at robotten kører normal hastighed efter første
			//kryds, og højere hastighed efter sidste kryds
			maxSpeed = 255;
			if(speedUpCross == true){
				speedUpCross = false;
				if(turboMode == true){
					turboMode = false;
					botSpeed = minSpeed;
					left = botSpeed;
					right = botSpeed;
				} 
				else if (turboMode == false){
					turboMode = true;
					left = 255;
					right = 255;
					minStreg= 900;
					maxSpeed = 120;
				}
			} 
			drive(left, right);
			botSpeed = 100;
		} 
		else {
			//Tjekker om en af sensorerne er på stregen
			if(lys1 < minStreg ){
				//Sensor 1 er ved ren streg!!!
				left = -255;
				right = 255;  
			} 
			if(lys3 < minStreg ){
				//Sensor 3 er ved ren streg!!!
				right= -255; 
				left = 255;  
			}
			drive(left,right);

		}
	}
}
void klodsMode(){

	//Højre skarpt
	drive(75,-200);
	delay(1300); 
	//Ligeud
	drive(250,250);
	delay(1200);
	//Venstre ca. 50 grader
	drive(-200,75);
	delay(1000);
	//Ligeud
	drive(255,255);
	delay(1950);
	//Venstre ca. 60 grader
	drive(-200,75);
	delay(1200);
	//Ligeud til højre sensor rammer streg,
	//hvorefter der køres normalt
	drive(250,250);
	while(true){
		lys3= printLight(readpin3);
		if(lys3 < minStreg ){
			break;
		} 
	}
}

void drive(int leftMotor, int rightMotor){
	//Dette er fremad for begge motorer
	boolean left = false;
	boolean right = true;

	//For at tillade at metoden kan bruges til når robotten skal køre
	//baglæns, så ændres retningen på motorerne, hvis en negativ værdi
	//er givet som parameter til metoden 
	if(leftMotor<0){
		left = true;
		leftMotor = -1*leftMotor;
	}

	if(rightMotor<0){
		right = false;
		rightMotor = -1*rightMotor;
	}

	//Motor A
	digitalWrite(12, right); //Retning
	digitalWrite(9, LOW);  //Bremse
	analogWrite(3, rightMotor); //Hastighed

	//Motor B
	digitalWrite(13, left); 
	digitalWrite(8, LOW);   
	analogWrite(11, leftMotor);   
}

//Sådan finder man afstanden fra afstandssensoren
int getDistance(){
	Wire.beginTransmission(112); 
	Wire.write(byte(0x00));  
	Wire.write(byte(0x50));    
	Wire.endTransmission();    
	delay(70);                 

	Wire.beginTransmission(112); 
	Wire.write(byte(0x02));    
	Wire.endTransmission(); 

	Wire.requestFrom(112, 2);

	if(2 <= Wire.available()) 
	{
		reading = Wire.read();
		reading = reading << 8;   
		reading |= Wire.read();
	}
	return reading;

} 

int printLight(int readPin){
	digitalWrite (Irpin, HIGH);
	int returnVal = analogRead (readPin); // 0 til 1023
	return returnVal; 
}

 

Konklusion

Robotten kan gennemføre banen på 47 sekunder – som bedste tid. Forhold som lys og indgangsvinkel kan dog påvirke tiden. Grundet gearing og størrelse på hjul er det ikke muligt for robotten at køre meget hurtigere end dette. Kalibrering af lyssensorer ved ændring af lysfølsomheden og afstanden fra lyssensor til gulvet kunne gøre at robotten tidligere ville kunne se sving – og derved forhindre at robotten ikke altid når at dreje nok i sving. I koden er der hovedsageligt blevet brugt metoder og if statements. De holder styr på hvor robotten er i forhold til stregen og forhindringen på banen.

Video

One thought on “POPG1 – Gruppe 4 (HvemStjalVoresBatterier)

Leave a Reply