Juul, Simon Helsted 
Rasmussen, Frederik Lau 
Rasmussen, Simon Møller 
Rudolf, Tom Lars Bo 

Opbygning 

Efter aftale med Jacob fik vi lov til at arbejde fire sammen, hvis vi lavede en solcellestyring med et 2-akse-system. Vi vurderede derfor, at vi ville få den mest præcise styring, hvis vi inkorporerede fire LDR-modstande, da det gav os mulighed for at beregne lysintensiteten på begge akser. Vi valgte at bruge en servo-motor til at styre tilten på solcellestyringen, da det ikke ville være muligt at skulle bevæge den mere end 180 grader. Til at rotere styringen valgte vi at bruge en DC-motor, da det gav os mulighed for at roterer 360 grader rundt. Vi valgte derfor at bygge vores platform høj nok til, at den kunne rumme en gearing under sig. 

Vi byggede gearing til DC-motoren ud fra vores krav om at kunne dreje solcelleplatformen langsomt nok til at styre den med en nogenlunde god præcision. I første iteration af gearingen brugte vi alle tandhjul vi havde og kom op på et gearingsforhold af 675:1. Det viste sig dog at det ikke var nok. Vi prøvede os lidt frem og fandt ud af at ormgear var løsningen på vores problem. I anden iteration af gearingen kom vi op på et gearingsforhold af ca. 130000:1, som vi testede og dømte alt for stort. Vi fjernede fire af tandhjulene og endte med et gearingsforhold af 5184:1, da vi vurderede at det gav os god kontrol over hastigheden som styringen roterede med. 

Motoren blev placeret i den ene ende af platformen, da det gav os plads til at lave gearingen på tværs af hele platformen. Yderligere placerede vi motoren med fronten mod jorden, da dette gav os mulighed for at placere gearene under platformen. 

Til styringen af DC-motoren brugte vi et H-bro komponent, L293D. Ved hjælp af H-broen kan man bestemme hvilken retning motoren kører, ved at styre strømmens retning. Hvis solen var til venstre for solcellen, kunne man dreje den lidt til venstre frem for at skulle dreje til højre hele vejen omkring sig selv. 

Solcellen består af 4 lys sensorer (LDR), som er monteret på et stativ som yderligere er sat fast på en servomotor. Stativet består af en plade med 2 vægge sat sammen i et kryds, således at stativet er opdelt i 4 segmenter. I hvert segment er der monteret én LDR. 

Vi brugte en del tid på at måle komponenterne op, da vi ville 3D-printe dele af vores solcellestyring, hvilket betød at vi havde en god ide om, hvordan vi skulle samle hele robotten. Derfor har robotten ikke ændret markant udsende i udviklingsprocessen. Vi opdagede dog at, vi kunne få en større præcision, hvis vi forlængede væggene mellem vores LDR-sensorer, hvilket var den eneste ændring vi har lavet på robotten. 

Hardware 

Diagramtegning

Opførsel 

Robottens primære opførsel er at bevæge sig mod de LDR-sensorer, som har den højeste modstand. For at gøre det, skal robotten bevæge sig funktion. Når programmet starter op, aflæses alle fire LDR-sensorer, hvorefter at “ServoControl” bliver kaldt. Her lægges værdierne for LDR-sensor 1,4 og 2,3 sammen, hvorefter differencen mellem de to værdier findes. Dette gøres for at bestemme om servoen skal øge eller mindske sin vinkel. Efterfølgende kaldes “DirectionControl”, hvor værdierne for LDR-sensor 1,2 og 3,4 lægges sammen. De bruges på samme måde som værdierne i “ServoControl”, men her bestemmer de bare hvilken retning at DC-motoren skal køre. Herefter køres loopet igen, for hele tiden at tjekke at sensorerne er inde for den godkendte difference, ellers flytter robotten sig igen. Yderligere er der en timer, som sørger for at streame data for hver LDR-sensor samt servoens vinkel til Excel hvert minut. 

void loop() {
  servoController();
  directionControl();
  controlLED();

  /*
   * I den sidste del af vores loop, tjekker vi hvor lang tid der er gået. Hvis den er lige så lang eller længere tid
   * end en periode variable kører vi vores readSensors funktion, som gemmer vores data fra sensorene. 
   * Så resetter vi vores counter, som gør at vi sender den dataen efter x sekunder.
   */
  
  currentMilli = millis();

  if(currentMilli - startMilli >= period)
  {
    readSensors();
    startMilli = currentMilli; 
  } 
}

/*
 * I directionControl finder vi to summer af to sensorer på hver side af vores solsensor. 
 * Så minusser vi dem med hinanden hvorefter vi finder differensen. Hvis den er større eller mindre 
 * end vores diff variable, skal den køres enten til højre eller venstre. Det sker ved hjælp af en H-bro. 
 * Hvis den er større kører DC-motoren til højre, og hvis den er mindre end vores -diff kører den til venstre.
 * Det skulle den blive ved med indtil at summen af de to sider er inde for vores differens. 
 * Når den ikke rykker sigere mere kan vi gå ud fra at DC-motoren er i den optimale position.
 */
void directionControl() {
  analogWrite(enB, 255);
  int diff = 7;
    
  sensorVal_1 = analogRead(sensorPin_1);
  sensorVal_2 = analogRead(sensorPin_2);
  sensorVal_3 = analogRead(sensorPin_3);
  sensorVal_4 = analogRead(sensorPin_4);

  int sensorSum_12 = sensorVal_1 + sensorVal_2;
  int sensorSum_34 = sensorVal_3 + sensorVal_4;

  if (sensorSum_12 - sensorSum_34 > diff) {
    isMoving = true;
    controlLED();
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    delay(500);
    digitalWrite(in3, LOW);
    digitalWrite(in4, LOW);
    isMoving = false;
  }
  else if (sensorSum_12 - sensorSum_34 < -diff) {
    isMoving = true;
    controlLED();
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    delay(500);
    digitalWrite(in3, LOW);
    digitalWrite(in4, LOW);
    isMoving = false;
  }
}

/*
 * I vores readsensors funktion, tager vi alle værdierne fra vores sensorer og nogle variabler vi har defineret.
 * Vi printer dem sp til Serial, hvilket gjorde vi kunne sende vores data til Excel til grafer og analyse.
 */
void readSensors() {
  sensorVal_1 = analogRead(sensorPin_1);
  sensorVal_2 = analogRead(sensorPin_2);
  sensorVal_3 = analogRead(sensorPin_3);
  sensorVal_4 = analogRead(sensorPin_4);

  //Data der udskrives til EXCEL
  Serial.print(sensorVal_1);
  Serial.print(",");
  Serial.print(sensorVal_2);
  Serial.print(",");
  Serial.print(sensorVal_3);
  Serial.print(",");
  Serial.print(sensorVal_4);
  Serial.print(",");
  Serial.print(sensorVal_1 + sensorVal_4);
  Serial.print(",");
  Serial.print(sensorVal_2 + sensorVal_3);
  Serial.print(",");
  Serial.println(servoPos);
}

/*
 * I controlLED har vi en bool variable, som bestemmer hvilken LED der er tændt.
 * Vi ændre den variable i både directionControl og servoController
 */
void controlLED() {
  if (isMoving) {
    digitalWrite(moveLED, HIGH);
    digitalWrite(onPointLED, LOW);
  }
  else {
    digitalWrite(moveLED, LOW);
    digitalWrite(onPointLED, HIGH);
  }
}

/*
 * Princippet i Servocontroller er den samme som med DC-motoren. Vi finder to summer af sensornes værdier. 
 * I servoen er det så toppen og bunden af vores solsensor. Vi kører den op eller ned hvis differensen er for stor
 * eller for lille.
 */

void servoController() {
  int diff = 7;
  int servoPosMin = 0;
  int servoPosMax = 180;
  
  sensorVal_1 = analogRead(sensorPin_1);
  sensorVal_2 = analogRead(sensorPin_2);
  sensorVal_3 = analogRead(sensorPin_3);
  sensorVal_4 = analogRead(sensorPin_4);

  int sensorSum_14 = sensorVal_1 + sensorVal_4;
  int sensorSum_23 = sensorVal_2 + sensorVal_3;

  if (sensorSum_14 - sensorSum_23 > diff) {
    isMoving = true;
    servoPos = servoPos - 1;

    if (servoPos < servoPosMin) {
      servoPos = servoPosMin;
    }
    
    servo.write(servoPos);
    delay(50);
  }
  else if (sensorSum_14 - sensorSum_23 < -diff) {
    isMoving = true;
    servoPos = servoPos + 1;

    if (servoPos > servoPosMax) {
      servoPos = servoPosMax;
    }
    servo.write(servoPos);
    delay(50);
  }
  else{
    isMoving = false;
  }
}

Implementeringen af nulstilling efter solen er gået ned, blev aldrig korrekt lavet. Den primære grund af dette er vores opbygning af robotten. For at løse opgaven var tanken at lade robotten finde sin start position når solen stod op. Herefter ville have to tællere som talte hvilken retning og hvor mange gange den flyttede sig samt værdien for servoen. Når solen gik ned eller at LDR værdierne kom under en bestemt værdi, skulle den back tracke til sin start position ved at loope igennem rotationsfunktionen. Problemet med vores opsætning var at motoren ikke præcist flyttede sig det samme hver gang den kørte, hvilket ville medføre at position kunne være forkert i forhold til start positionen. Problemet var pga. modstand fra ledninger og i gearingen, hvilket medførte at den somme tider ville køre langsommere eller helt stoppe.

Test 

Vi har logget data fra systemet under en test på ca. 4,5 time – herunder værdier for lyssensorer og servopositionen. Dataene er efterfølgende blevet opstillet i forskellige grafer. 

I ovenstående diagram er de fire værdier fra lyssensorerne indsat. Baseret på vores kode og opsætning, bør de alle fire ligge forholdsvis tæt, I det at en nogenlunde ensartet værdi på tværs af sensorerne skulle betyde at servomotoren er vinklet imod solen. Dette er også hvad vi kan se på grafen, at alle fire sensorer ligger nogenlunde ens. De store udsving der ses I grafen, er grundet skyer som har blokeret for solen. 

Yderligere har vi logget vores servo position, og sammenholdt denne med den reélle elevationsvinkel for solen. Generelt passer vores servoposition inden for ca. 2 – 5 grader, med den egentlige vinkel på solen. Her ses også store udsving I vores servoposition. Dette er grundet skyer foran solen, hvilket har resulteret I at himlen lige over systemet har afgivet mere lys, og servoen har derfor rettet sig ind efter dette, og tilbage til solen når skyerne har passeret. 

Efter vi havde samlet og testet vores solcelle, fandt vi nogle mangler ved vores produkt. Et af de største problemer vi stødte på under vores test var, hvis skyer var til stede på himlen, fungerede solcellen ikke optimalt. Hvis der gik en sky for solen, kunne det resultere i at andre skyerne reflekterede lyset fra solen, hvorefter robotten opfattede disse skyer som den stærkeste lyskilde. Derfor ville det kræve direkte sollys fra en skyfri himmel, hvis den skal fungere optimalt.  

Vi observerede også diverse problemer med vores opstilling af robotten. Ledninger kunne komme I vejen hvis solcellen skulle dreje for meget om sig selv. Vi mener også at gearene skulle stabiliseres mere end de allerede var, da man blev nødt til at lægge vægt på bestemte steder, før de fik rigtig fat i hinanden. Sammen med opgraderinger til hardware, kunne vi også gøre vores software mere effektiv. Måden lysene fungere skulle ændres da de blinker mellem rød og grøn, selvom den stadig bevæger sig. 

Konklusion 

På trods af nogle mangler, vurderer vi at der er blevet udviklet et tilfredsstillende produkt, som formår at finde den stærkeste lyskilde. Hvis man ser på grafen for servoens vinkel i forhold til solens vinkel på himlen, kan man se at den hovedsageligt følger solens bane inden for et par grader. Hvis man sørgede for at ledningerne til sensorerne og servoen ikke var snoet rundt om solcellen, fungerede gearingen af DC-motoren som den skulle, og vi havde god kontrol over roteringen af solcellen. 

Leave a Reply