Mads Kildegaard Kristjansen & Lucas Brynk Jensen

Introduktion 

At konstruere en solcellestyring, der drejer efter solens lys ved hjælp af en motor for at optimere udnyttelsen af solens energi, var den opgave der blev stillet. Hvordan en sådanne enhed kan konstrueres, samt kodes, vil der blive givet et forslag til i denne dokumentation. Solcellestyringen skal kunne køre 180 grader rundt om sin egen Y – akse, hvorefter den returnerer til sin oprindelige position. Derudover skal motoren have en blød opstart og nedbremsning. Styringen skal som udgangspunkt følge solen. Enheden skal bestå af en Arduino Uno, en Lego DC-motor, en H-bro, samt én eller flere LDR-modstande. 

Grundet manglede komponenter vil dette opslag beskrive SolarFriend delvist som en fysisk konstruktion af Lego, samt en teoretisk opsætning simuleret i TinkerCad. Vi vil tage udgangspunkt i vores oprindelige konstruktion samt gearing med Lego fra inden COVID-19 krisen, og senere implementere vores nye system udarbejdet i TinkerCad. 

Figur 1 – Oprindelige konstruktion

Systemets Opbygning

Med tanke på at enheden skulle agere roterende “solcelle”, blev SolarFriend opbygget som en slags “fabrik”. For at opnå dette blev enheden opbygget af Lego. Dette gjorde det muligt at bygge et stativ hvor gearingen kunne sidde, samt have fri bevægelighed. Gearingen består af 3 gear og en snekkeaksel, som har til formål at nedsætte hastigheden på motoren. Motoren, som er en Lego DC-motor, kunne sættes direkte i forlængelse af gearingen. Derudover er der tilføjet en Arduino Uno, med påført Motor Shield, Lysdioder for indikation, breadboard med to LDR-Modstande, resistorer og ledninger, samt en H-bro. 

Gearing 

Snekkeakslen består af 6 vendinger. I forlængelse af denne snekkeaksel er sat et gear. Dette gear består af 24 tænder. Her for vi den første gearing. Den trækaksel som sidder fast på gear nr.2 går op til et nyt gear der består af 11 tænder, og i forlængelse af dette gear sidder det sidste gear, som består af 22 tænder. 

Ratioen mellem gear 1-2 og 3-4 giver så en udveksling på hhv. 24-1 og 3-1. Mellem gear 2-3 er en udveksling på 1-2. Det giver en samlet ratio på 36:1. Dette betyder at motoren laver 36 omdrejninger før solcellepladen har lavet én rotation. 

Figur 2

Strøm, spænding og modstande

Systemet skal kunne opfange lys, derfor er LDR-sensorer benyttet til denne opgave. Da Arduino måler i volt (grundet det indbyggede system ved navn “Analog to Digital Converter (ADC)) brugte vi en ekstra modstand som referencepunkt (en spændingsdeler) for at kunne måle volt forandringerne. Ved hjælp af Ohms lov fandt vi frem til følgende:

Strømstyrken gennem systemet:

I = V / R 

Da vi i systemet har en “V in” og 2 modstande, kan det også noteres på denne måde

I = Vin / (R1+R2)

Hvor Vin = 5V, og vores LDR-modstand (R1) havde en minimumværdi på 6,5 kOhm og max 13,5 kOhm. R2 valgte vi at bruge 10kOhm på baggrund af anbefalingerne fra denne side: (https://www.instructables.com/id/How-to-Use-a-Light-Dependent-Resistor-LDR/?fbclid=IwAR1y4NyYJvHT6n7_Msk5Gt3PhJ_yr2lD_bbDA_5nxKEBTSzVU6HaXH6H5hI)

Altså kan vi sige:

Vout = I * R2 

Samler vi de 2 formler kan vi udlede følgende formel: 

Vout = Vin * R2 / (R1+R2) 

Sætter vi vores værdier (ved max kOhm for LDR) ind i formlen for vi følgende: 

Vout = 5 * 10000 / (13500 + 10000) = 2,13V

Og sætter vi vores værdier (ved min kOhm for LDR) ind i formlen for vi følgende: 

Vout = 5* 10000 / (6500 + 10000) = 3,03 

(Gennemregningerne er lavet med hjælp fra følgende side: (https://www.instructables.com/id/How-to-Use-a-Light-Dependent-Resistor-LDR/?fbclid=IwAR1y4NyYJvHT6n7_Msk5Gt3PhJ_yr2lD_bbDA_5nxKEBTSzVU6HaXH6H5hI

Med en teoretisk opbygning i TinkerCAD kan man konstatere at beregningerne er i orden. 

Figur 3

Via koden har vi oversat resultatet til en værdi man kan bruge, og det resultat vi ender med, svarede overens med det beregnede resultat. 

H-Bro 

Grundet manglende komponenter var vi ikke i stand til at implementere en fungerende H-bro i vores oprindelige konstruktion. I dette afsnit vil vi redegøre for, hvordan man kan opbygge en H-bro samt dens funktion. Dette har vi implementeret i vores nye teoretiske opsætning af vores konstruktion. 

En H-bro er en parallelforbindelse som styrer strømmens retning via en række transistorer. Ved at aktivere vores transistorer (High/Low) kan vi bestemme strømmens retning og kredsløbets polaritet (se figur 4). 

Figur 4

H-broen bruges typisk når man anvender en motor i ens konstruktion. Fordelen ved en H-bro er, at man kan ændre på strømmens retning igennem motoren, og derved skifte hvilken vej motoren skal køre. Det kunne eksempelvis være motoren i en bil, der kunne være fordelagtig at skifte hvilken vej bilen skal køre. I vores tilfælde vil vi have solcellen til at køre rundt med solen, for derefter at køre tilbage til startposition når den er færdig.

Diagramtegning og de brugte komponenter 

Figur 5 – Illustrerer SolarFriend systemet, som det ser ud nu teoretisk

Koden

//We start of by declaring the variables we need
int east = A3;
int west = A2;
int sensorValue1 = 0;
int sensorValue2 = 0;
int sensorDifference = 50; //Maximum allowed difference between east and west sensor values

void setup() 
{
//Green
pinMode (4, OUTPUT);
//Yellow
pinMode (5, OUTPUT);
//Red
pinMode (6, OUTPUT);

//Motor
pinMode (9, OUTPUT);
pinMode (3, OUTPUT);
digitalWrite (9, LOW);
digitalWrite (3, LOW);

Serial.begin(9600);
}


void loop() {

//We start the loop by reading our east and west sensor values
sensorValue1 = analogRead(east);
sensorValue2 = analogRead(west);
Serial.println(sensorValue1);  
Serial.println(sensorValue2);
delay(500);

	if(sensorValue1 > sensorValue2 + sensorDifference)
	{
  		//Check if east sensor's value is higher than west sensor plus the assigned difference
  		//For-loop for acceleration of positive rotation
  		for(int k=0;k<255;k+=15)
  		{
    		   analogWrite(3, k);
    		   analogWrite(9, 0);
    		   digitalWrite(4, HIGH); //Green LED is on to indicate positive rotation
    		   digitalWrite(5, LOW);
    		   digitalWrite(6, LOW);
    		   delay(50);
  		}
  		delay(500);
  
  		//For-loop for deacceleration of positive rotation to stop
  		for(int m=255;m>=0;m-=15)
  		{
    		   analogWrite(3, m);
    		   analogWrite(9, 0);
    		   digitalWrite(4, HIGH);
    		   digitalWrite(5, LOW);
    		   digitalWrite(6, LOW);
    		   delay(50);
  		}
  		delay(500);
	}

  
	if(sensorValue2 > sensorValue1 + sensorDifference)
	{
  		//Check if west sensor's value is higher than east sensor plus the assigned difference
  		//For-loop for acceleration of negative rotation
  		for(int l=0;l<255;l+=15)
  		{
    		   analogWrite(9, l);
    		   analogWrite(3, 0);
    		   digitalWrite(4, LOW);
    		   digitalWrite(5, LOW);
    		   digitalWrite(6, HIGH); //Red LED is on to indicate negative rotation
    		   delay(50);
  		}
  		delay(500);
  
  		//For-loop for deacceleration of negative rotation to stop
  		for(int n=255;n>=0;n-=15)
  		{
    		   analogWrite(9, n);
    		   analogWrite(3, 0);
    		   digitalWrite(4, LOW);
    		   digitalWrite(5, LOW);
    		   digitalWrite(6, HIGH);
    		   delay(50);
  		}
  		delay(500);
	}

  	//Check if absolute difference between east and west sensors is below assigned difference
	if(abs(sensorValue1 - sensorValue2) < sensorDifference)
	{
  		//If difference is not high enough, we stop the motor
    	   analogWrite(3, 0);
    	   analogWrite(9, 0);
    	   digitalWrite(4, LOW);
    	   digitalWrite(5, HIGH); //Yellow LED is on to indicate standstill or "standby mode"
    	   digitalWrite(6, LOW);
	}

	if(abs(sensorValue2 - sensorValue1) < sensorDifference)
	{
    	   analogWrite(9, 0);
    	   analogWrite(3, 0);
    	   digitalWrite(4, LOW);
    	   digitalWrite(5, HIGH);
    	   digitalWrite(6, LOW);
	}
}

I koden har vi angivet 5 variabler som skal bruges. I void setup fortæller vi hvilke pins vi kommer til at bruge. Pin 4-6 er hhv. grøn, gul og rød LED. Pin 3 og 9 er motor. Derudover starter vi serial monitor.  

Void Loop er den del af koden der gentager sig selv. Det er også her det meste kode indgår, i SolarFriend softwaren. SensorValue 1 og 2 bliver vores LDR værdier, som bliver sendt til monitoren, så vi kan læse dem. Et delay er sat til 500, hvilket betyder at koden i princippet bliver kørt igennem hver halve sekund, hvis ikke andre delays bliver mødt.  

De 4 “if” statements som tjekker om en rotation er påkrævet gør hhv. som følgende:  

If Statement 1: Hvis sensorValue1 er større end sensorValue 2 + den maksimale forskel mellem sensorValue 1 og 2, så kører motoren (altså rotere SolarFriend) med uret, hvortil den grønne LED bliver tændt.  

If Statement 2: Hvis sensorValue 2 er større end sensorValue 1 + den maksimale forskel, så kører motoren modsat, samt den røde LED tændes. 

If Statement 3: Hvis sensorValue 1 og 2 trukket fra hinanden er mindre end den maksimale forskel, står motoren stille og herved lyser den gule LED. 

If Statement 4: Hvis sensorValue 2 og 1 trukket fra hinanden er mindre end den maksimale forskel, står motoren stille og herved lyser den gule LED. 

Første og anden “if” statement indeholder hver to “For” loops som sørger for at accelerere motoren ved opstart, samt decelerere motoren ved nedbremsning. Herudover er 2 x 2 delay() insat for at styre hvor længe motoren skal køre.

Figur 6 – Flow-diagram

Perspektivering & forbedringer

Eftersom vores oprindelige konstruktion var meget mangelfuld med hensyn til komponenter, så valgte vi at opbygge et nyt system via TinkerCad. I forhold til vores oprindelige konstruktion, så har vi tilføjet en fungerende H-bro, implementeret en acceleration og nedbremsning til vores motor, samt anvendt to LDR-modstande i modsætning til kun én. 

I vores gamle system havde vi implementeret en metode til at tælle op hver gang solcellen bevægede sig med solen. Når denne tæller nåede op til en bestemt værdi vi angav som værende maksimum eller “slutpunkt”, så vil konstruktionen nulstilles tilbage til startposition. Denne metode blev beregnet ud fra tid, hvilket vi blev gjort opmærksomme på kan være meget risikabelt. Grunden til dette er, at det kun vil fungere i et lukket og kontrolleret system uden forstyrrelser. Så snart andre faktorer spiller ind såsom vægt, vejr eller lignende som kunne nedsætte motorens omdrejninger, så vil resultaterne have for store udsving og ikke være pålidelige. 

Potentielt set, så skulle vores nuværende konstruktion med to LDR-modstande kunne rette sig tilbage til “startpunkt”, så snart sensorerne registrerer solopgangen. For at udvikle og sikre en mere nøjagtig nulstilling af solcellen, så kunne man gøre brug af enkodere. Enkodere er komponenter til at måle og registrere bl.a. rotation og hastighed af en motor, og med dets inputs kunne man implementere et system til at indstille solcellens position når den skal nulstilles. 

Konklusion 

Grundet diverse udfordringer og manglede komponenter, så har vi udarbejdet et teoretisk system i TinkerCad baseret på vores oprindelige fysiske konstruktion. Da det ikke har været muligt at teste vores nye system fysisk, så kan vi ikke definitivt sige om hvorvidt det vil fungere i praksis, men vi må konkludere ud fra vores simulering at det agerer korrekt. 

Vi mener derfor at vi opfylder opgavens krav tilstrækkeligt og, på baggrund af den feedback vi modtog fra vores oprindelige konstruktion, har udarbejdet væsentlige forbedringer i vores nye system. 

Video demo

TinkerCad simulation

Leave a Reply