Af: Mads Boy Lindholm og Huy Minh Luu Tran

Robottens navn: Ben Affleck

Tanker bag designet

Vi har haft til opgave at skulle konstruere et system eller robot der ved hjælp af en LEGO motor skulle fungerer som en solcelle, der ville dreje efter solens lys og derved optimere udnyttelsen af solens lys. Nedstående billede er af selve konstruktionen.

Skærmbillede 2016-04-01 kl. 00.10.12

Den nederste del af konstruktion er systemets gearing. Anvendelse af tandhjul medfører, at motoren drejer flere omgange pr cyklus og derved også kan få en langsommere hastighed, hvilket er idealt i forbindelse med denne opgave. På den anden side giver gearingen også flere kræfter til systemet og kan derfor trække mere. Alt gearingen er blevet indkredset af LEGO klodser for at give konstruktionen et mere poleret udseende. Uden for gearingen sidder LEGO motoren. Den er bevidst blevet placeret der af hensyn til praktiske grunde f. Eks. For ikke at skulle stå i vejen for alt gearingen.

Robottens opførsel

Søjlen er der hvor de to LDR sensor er placeret. Der er blevet brugt to LDR sensorer for kunne dikterer ved hjælp af kode hvilken vej motoren skulle kører. Det har været muligt at placerer dem på søjlen ved hjælp af nogle lange ledninger. Vi har prøvet at gøre ledningerne som er forbundet til LDR sensorerne så usynlig som muligt ved at vikle dem rundt om nogle LEGO klodser der havde nogle huller. Hvis én af sensor måler over 10 % vil den finde ud af hvor meget forskel der er på den anden sensor. Derefter LEGO motoren dreje for at søge efter lyset, indtil at der skinner lige meget lys på begge sensor. Der er placeret en LEGO klods imellem de to LDR sensor for at sikre at hele tiden vil skinne lige meget lys på de to sensorer. Klodsen kaster skygger i forhold til hvor lyset kommer fra, dette og koden gør, at motoren kører indtil der skinner lige meget lyst på begge sensorer.

I bunden af søjlen er der placeret to knapper. Disse knapper gøre, at sensorerne cirka kun kan dreje 180 grader da systemet vil være 90 rettet mod syd og bevæge sig fra øst til vest. Når den ene knap bliver trykket ned vil sensorerne være retter mod vest og solen er gået ned. Derefter vil sensorerne gå tilbage til dens oprindelige position.

Bag ved konstruktionen ses et breadboard, hvor der er brugt nogle 4.7 k resistor i forbindelse med LDR sensorerne. Breadboardet har fungeret som et mellem led mellem sensorerne og arduinoen. Der er mere præcist blevet anvendt en Arduino motor shield som kan kobles til en LEGO DC motor. Hele systemet får strøm fra en bærebar via et USB kabel. Det har været et bevidst valg at tag strøm fra en bærbar, da strøm fra en stikkontakt gav LEGO motoren for meget kræft i forhold til hvad den skulle udføre.

Ændringer af designet

12946996_10208910204973641_829611146_o

Systemet har ændret udseende i løbet af dens udviklingscyklus. Ovenfor ses et billede af en meget tidlig udgave af systemet. Det er tydeligt at der er sket meget siden. Ændringerne skyldes, at vi efterhånden har fået en bedre forståelse for de forskellige aspekter og komponenter der udgøre opgaven. Den tidlig udgave fungerede mest af alt som en prototype til testning af LDR og LEGO motor.

Implementering af robottens opførsel

Vi har i forbindelse med implementering af robottens opførsel anvendt et diagramtegning, flowdiagram og kode.

Diagramtegning af systemet:

Skærmbillede 2016-03-31 kl. 23.44.35

Flowdiagram af koden til robottens opførsel:

Skærmbillede 2016-03-31 kl. 19.36.15

Selve koden for implementering af robottens opførsel:

const int sensorPin0 = 0; // Venstre LDR
const int sensorPin1 = 1; // Højre LDR
const int inputPin2 = 2;  // Knap 1
const int inputPin4 = 4;  // Knap 2
int diff = 0;
int done = 0;
const int threadhold = 10;
const int turnspeed = 255 ;
void setup()
{
  Serial.begin(9600);
  pinMode(inputPin2, INPUT);
  pinMode(inputPin4, INPUT);
  digitalWrite(inputPin2, HIGH);
  digitalWrite(inputPin4, HIGH);
  pinMode(12, OUTPUT);
  pinMode(9, OUTPUT);
}
void loop()
{
  int rightLDR = analogRead(sensorPin0); // Læser vores analog inputs
  int leftLDR = analogRead(sensorPin1); 
  int button1 = digitalRead(inputPin2);  // Læser vores digitale inputs
  int button2 = digitalRead(inputPin4);
  rightLDR = map (rightLDR, 100, 1023, 0, 100); // Omsætter vores værdier til procent fra 100 til 1023
  leftLDR = map(leftLDR, 100, 1023, 0, 100);
  //Serial.print(button1);      // Test af Knapper
  //Serial.print(button2);
  //Serial.println(done);
  //Serial.print("Sensor 0: ");  // Test af LDR
  //Serial.println(rightLDR);
  //Serial.print("Sensor 1: ");
  //Serial.println(leftLDR);
  if (button1 == LOW) {
    done = 1;                 // Knap 1 bliver ramt ved enden af cyklus sætter done til 1.
  }
  if (button2 == LOW) {       //  Når knap 2 bliver ramt er den nået til sin originale postion.
    digitalWrite(12, HIGH);   // Den drejes et par grader til siden for ikke at ligge knappen under pres.
    digitalWrite(9, LOW);
    analogWrite(3, 100);
    delay(3000);              // Køre i 3 sekunder væk fra knappen.
    done = 0;                 // done sættes til nul, klar til ny cyklus.
    delay(0);
  }
  if (rightLDR > threadhold || leftLDR > threadhold && !done) { // Hvis lystyrken er over vores grænseværdi på hverken LDR 1 eller 2 og hvis den ikke resetter.
    diff = abs(rightLDR - leftLDR); //finder differensen på de 2 værdier og gør den absolut (Positiv)
    if (diff > 5) {
      if (rightLDR < leftLDR && button1 == HIGH) {
        Serial.println("Lolololo");
        digitalWrite(12, HIGH);       //Fremad
        digitalWrite(9, LOW);         //Sæt bremsen fra
        analogWrite(3, turnspeed);    //Sætter motor til fuld fart.
      }
      else if (rightLDR > leftLDR && button2 == HIGH) {
        Serial.println("HUEHUEHUE");
        digitalWrite(12, LOW);        //Bagud
        digitalWrite(9, LOW);         //Sætter bremsen fra
        analogWrite(3, turnspeed);    //Sætter motor til fuld fart
      }
    }
    else { // Hvis begge sensor næsten har samme lys, så stop motor
      digitalWrite(9, HIGH);
      analogWrite(3, 0);
    }
  }
  if (done) {                 // mens done er true, bevæger moteren sig tilbage tilbage til originale position. 180 grader.
    Serial.println("DONE!");
    digitalWrite(12, LOW);
    digitalWrite(9, LOW);
    analogWrite(3, turnspeed);
  }
  delay(5000);
}

Udfordringer i forhold til hardware og kode

Selve arbejdet med noget fysisk har været anderledes i forhold til tidligere opgaver, hvilket har givet nogle interessante udfordringer. Gearingen og placeringen af de forskellige komponenter af systemet har været den største udfordring. Der skulle en eksperimenteres en del før, løsningerne kom frem. Håndtering af de lange ledningerne har også været udfordrende til tider. Forståelse af kode har givet vanskeligheder i starten af forløbet. Der har været nogle problemer med at få knapperne til at virke ordentligt rent kodemæssigt.

Forbedringer med hensyn til hardware og kode

I forhold til koden er der mange måder opgaven kunne løses på. Vi har i denne opgave valgt at tage udgangspunkt i difference mellem de LDR sensorer med hensyn til styring af LEGO motoren. Ydremere kunne koden også optimeres flere steder. I forhold til hardwaren  kunne der være mere plads på søjlen for at give plads til en solcelle som faktisk kan udnytte solens energi. Anvendelsen af LDR sensorerne på konstruktionen kunne også være mere stabil og sensorerne kunne derfor til tider virke en anelse for følsomme.

Konklusion

Alt i alt lykkes det at konstruerer et system som fungerede som en solcelle der kunne rette sig efter solens lys. Dette blev gjort muligt ved hjælp af Arduino motor shield, en LEGO DC motor, to LDR sensor, en masse LEGO klodser og noget kode. Der var diverse problemer undervejs, men det var ikke noget uoverkommeligt. Vi endte med konstruktion som meget fint opfyldte de krav der blev stilet i opgaveformuleringen, og som selvfølgelig stadig havde plads til forbedringer både hardware og kodemæssigt.

Video

Leave a Reply