Af Dune Zerna, Firat Yesilgül og Mathias Ø. Hansen

Figur 1 – Solfanger v2.0

Projektet

I en portofolio opgave stillet af kurset, fik vi til opgave at bygge et solcellesystem. Solcellen skulle fungere som et system i fuldt format. Solcellesystemet skal derfor i sit virke kunne rotere omkring 180 grader gentagende gange uden besvær. Til systemet var kravet at vi skulle bygge systemet udelukkende vha. LEGO™, Arduino og dertilhørende sensorer, eksempelvis Light dependent resistors (LDR).


Metode og fremgang

Med opgavebeskrivelsen klar og tydelig, var der problemstillinger vi blev nød til at løse:

  • Rotationsaksen, den skal kunne rotere selvstændigt frem og tilbage
  • Gearing, rotationen skal ske i et roligt og kontrolleret tempo
  • Kabelstyring, kablerne skal ikke tage skade af langvarig brug 

Det første der skulle ske, var at bygge selve robotten mekanikken ud af LEGO. Dette skete over to gange, den første blev brugt på at forsøge sig frem med forskellige gearing og tandhjul for at undgå kabelslitage og mulighed for inkorporering af potentiometer. Imens af opbygningen af den første robot skred fremad indså vi at den ville ende ud med at blive alt for ustabil og porøs. Derfor besluttede vi os for at gå over til Solfanger v2.0 hvor det var muligt for os at tage højde for vægtfordeling og større overblik over den endelige opbygning.


Mekanisk opbygning

Motoren der er brugt til projektet, er en LEGO™ 9V motor. Motoren er monteret ovenpå tandhjulet der roterer hele den øverste del af systemet. Forbundet med motoren er gearingssystemet der består af en snekke og snekkehjul. Snekkegearet er egnet til overførsel af kraft og bevægelse mellem krydsende, roterende aksler, som regel vinkelret på hinanden (Gyldendal, 2019). Brugen af snekkegear betyder at drivkraften kun kommer fra motorens side af snekkegearet. Tandhjulet der roterer systemet er placeret således at i bunden af tandhjulet er vores potentiometer sat fast så der er i toppen sidder en form for ”klo” der trækker potentiometeret med rundt.


LDR’s og potentiometer

LDR’s, også kaldet photoresistorer, er placeret øverst på platform i vinkelret mod solens position. De reagerer på lysintensiteten således at jo mere lys den opfanger jo mindre er modstanden i sensoren. Ved hjælp af et analog input i arduinoen kan vi derfor få en værdi mellem 0 og 1023. Grunden til dette er smart er at vi ved hjælp af to LDR’s kan skelne mellem hvilken én af dem der får mest sollys, som så sørger for at arduinoen kan dreje sig mod solen i løbet af dagen. Et af problemerne vi løb ind i da vi opsatte LDR’ne var at begge ben var blevet sat igennem samme hul i Legobrikken, dette resulterede i at benene rørte hinanden, og gav os en forkert værdi. Dette var løst ved bare at rykke det ene ben én tak ned.  
Når dagen er omme, peger systemet mod vest, men det ville klart være bedst hvis den automatisk rettede sig mod øst, der hvor solen står op. Derfor bruger vi potentiometeret til at holde øje med hvor langt maskinen er drejet. Potentiometeret virker lidt ligesom LDR’ne, den har en tap der kan drejes og alt afhængig af hvor meget den er drejet får vi et analogt signal. Denne værdi bruges som grænseværdi for hvornår maskinen skal resette. Derfor er potentiometeret både sat fast på fundamentet og den øvre del af maskinen. Dette begrænser dog konstruktionen så den ikke kan dreje 360 grader rundt men maksimalt omkring 270 grader. Hvilket betyder at når man sætter den op i vinduet eller udenfor skal man lige vende den nogenlunde korrekt.


Hard-, og software

Programmeringssproget der er brugt til projektet, er skrevet i Arduinoversionen C++. Arduinoen, der er den mikrochip controller der styrer systemet, og afgøre systemets opførsel.

Figur 2 – Diagram over hardware

Kode

Vi starter med at initialisere vores light dependent resistor og potentiometeret til nogle pins. Derefter laver vi nogle variabler, som vi efterfølgende vil bruge.


int sensorPin1 = A0;
int sensorPin2 = A1;

int sensorValue1 = 0;
int sensorValue2 = 0;
int sensorTresh = 400;

int potPin = A4;

int treshold = 150;
int reset = 800;

int potValue = 0;

boolean sunshine = false;

Derefter initialiserer vi motoren og indstiller datahastigheden til 9600 bits per sekund (baud), til seriel dataoverførsel.

void setup() {
//Initiate Motor and brakes.
  pinMode(12, OUTPUT); //Initiates Motor Channel A pin
  pinMode(9, OUTPUT); //Initiates Brake Channel A pin
  Serial.begin(9600);
}

Vi sætter de tidligere lavet variabler til at være det læste data på hhv. potentiometeret og ldr sensorerne. Da tallet fra sensorerne var ret lave (20 uden lys, 40 med lys), valgte vi at gange tallet, der blev læst med 10, så der var et større område at arbejde i.

void loop() {
   Serial.print(potValue);
   //delay(1000);
   // Setting sensorValue to the read ldr sensor value
 sensorValue1 = (analogRead(sensorPin1)*10);
 sensorValue2 = (analogRead(sensorPin2)*10);

//Setting potValue to the read potentiometer value
 potValue = analogRead(potPin);

Dernæst har vi if else statements, der får det hele til at spille. Hvis de to ldr sensorer opfanger lys, som er over 700, kører vi solarForward funktionen. Hvis potentiometerets værdi er lavere end threshold og sunshine er sand, kører vi solarBackward funktionen. Hvis potentiometerets værdi er lige med, eller større end reset variablen, kører vi brake funktionen.  Og, som en sikkerhedsforanstaltning, sørgede vi for, at i alle andre tilfælde kørte vi også brake funktionen.

// If the either one of the ldr values exceeds 700 we set the sunshine bool to true and start the solarForward function.
   if (sensorValue1 >= 700 || sensorValue2 >= 700) {
    delay(1000);
    sunshine = true;
    solarForward();
    Serial.println("There is sun!");
    Serial.println("This is the potValue: ");
    Serial.print(potValue);
    delay(1000);
    
    // or else if the potentiometer value is lower than the treshold (150) and the boolean sunshine is true, the solarBackward function runs
 } else if (potValue <= treshold && sunshine == true) {
    solarBackward();
    Serial.println("There is no sun!");
    Serial.println("This is the potValue: ");
    Serial.print(potValue);
    delay(1000);
    // If the value of the potentiometer exceeds the reset variable, we set the boolean sunshine to false and run the brake function.
 } else if (potValue >= reset) {
    sunshine = false;
    Brake();
    
    // If nothing happens, we run the brake function. 
 } else {
    Brake(); 
 }

Til sidst har vi funktionerne, som bliver kaldet. solarForward funktionen får motoren til at køre. solarBackward funktionen får motoren til at køre modsat vej i 15 sekunder, hvilket svarer til startpunktet. I Brake funktionen stopper vi motoren.

// Running the motor at half speed.
void solarForward () {
    digitalWrite(12, HIGH); //Establishes forward direction of Channel A
    digitalWrite(9, LOW);   //Disengage the Brake for Channel A
    analogWrite(3, 100);   //Spins the motor on Channel A at half speed //Changed from 123 to 60
  
}

// Resets the collector to its start point
void solarBackward () {
     Serial.println("RESETING");
     digitalWrite(12, LOW); //Establishes backward direction of Channel A
     digitalWrite(9, LOW);   //Disengage the Brake for Channel A
     analogWrite(3, 200);   //Spins the motor on Channel A at half speed
     delay(15000);
    
}
// Stops the motor
void Brake(){
   digitalWrite(12, HIGH);
    digitalWrite(9, HIGH);// Stop ----Stops quick
    analogWrite(3, 0);
    delay(5);
    digitalWrite(12, LOW);
    digitalWrite(9, LOW);// Stay --- Stopped 
    analogWrite(3, 0);
}

Vores største udfordring ift. Koden har været, at få motoren til at stoppe helt og derefter at nulstille den, til startpunktet.

Figur 3 – Flowchart over systemtilstande

Den endelige opstilling

Det svære ved denne opstilling er at få hele platformen til at balancere korrekt. Systemet har vist sig at være meget ustabilt ift. balancen og platformen giver sig til tider til at vælte. Kabelstyringen er heller ikke optimal, men trods omstændighederne, som manglende designering af de elektriske komponenter, fungerer det. De oprindelige problemstillinger er dog løst, maskinen kan rotere om sig selv godt nok til at følge solen i dagtimerne og køre tilbage til en startposition ved slutpunktet, altså solnedgangen. Som tidligere nævnt er der dog den udfordring ved dette at den skal placeres nogenlunde korrekt når den sættes op første gang. Den ville ikke på nuværende kunne stå uafhængigt og fungere størstedelen af tiden uden manuel justering efter hvert kørt forløb. Komponenter som batterihylster samt batterier, Arduino og PCB’en er løseligt sat til systemet, der påvirker stabiliteten i hele systemet i den negative retning, ved at hvis en enkelt ting falder af så kommer der ubalance og opsætningen vil tippe. Når det så er sagt, så er systemet forbedret ift. første iteration, og under kørslen fungerer den også efter hensigten i rimeligt omfang.

Figur 4 – Opstillingen
Video af Solfanger i aktion

Motorshield

Motorshieldet er en dual full-bridge driver, som tillader os at bruge to DC-motorer. Hvor vi bade kan kontrollere hastigheden og retningen af hver motor selvstændigt. Shieldet har to seperate kanaler, A og B, der begge bruger 4 pins til at vælge rotationsretningen, variere hastigheden, bremse eller måle den strøm, der strømmer gennem motoren. I alt er der 8 pins i brug på dette skjold. Du kan bruge hver kanal separat til at køre to DC-motorer eller kombinere dem til at køre en bipolær stepper motor. Skjoldet kan levere 2 ampere per kanal, i alt maksimalt 4 ampere. Det giver dig også mulighed for at kunne power en motor med en separat strømforsyning på op til 12V.

Grundet, at motoren kan skifte rotationsretning, har vi derfor valgt at bruge motorshieldet, da den har en H-bro indbygget, hvilket gør det muligt, at skifte retningen af strømmen, så den både kan køre frem og tilbage.

Konklusion

Solfanger v2.0 viste sig at være en delvis forbedring af første iteration, der tilnærmelsesvis opnåede de mål der blev sat for øje. Til eftertanke skal der i fremtiden skabes et bedre stel til de elektriske komponenter samt laves test på produktets holdbarhed over flere forløb. Derudover skal der også sættes mere tid i at bygge designeret positioner til de enkelte komponenter. Systemet kunne også forbedres ved at centrere alle komponenter tættere på det primære tandhjul, så vægtbalance og fordeling ikke har betydning for at funktionaliteten. Hvis ovenstående kunne implementeres, ville hypotesen også være at der ikke er behov for et større fundament. Den lidt porøse opbygning af maskinen gør dog også at den bedst egner til at blive stående i vinduet fremfor ud på græsplænen da vinden godt kan tage fat i den og vælte den.

Leave a Reply