Opbygning:

Vores solcelle platform med tilsluttet motor

Tanken bag vores opbygning af solcelle platformen er at bygge en solid konstruktion, som kan holde vores komponenter stabilt på plads, og hvor der samtidigt vil være plads til gearing mellem motoren og den roterende platform, som “solcellen” skal monteres på. Vores oprindelige konstruktion var lidt mindre, men da vores “solcelle” (efter vores mening) roterede for hurtigt var vi nødsaget til at udbygge med et lille gearings stykke. Vi havde oprindeligt en plan om at have fastmonteret motoren på selv konstruktionen, men da vi blev nødsaget til at udbygge gearingen valgte vi at bygge en separat stander til den. Det har dog hele tiden været meningen at motoren skulle monteres på siden af konstruktionen.  Selv meningen med konstruktionsopbygning var at vi ville kunne placerer en plade på toppen af konstruktionen sov ville være der hvor vores “solcelle” ville skulle fastmonteres på. Selve placeringen af hvor denne plade er blevet monteret er ændret sig en smule da vi igen skulle tilføje mere gearing. 

Hele pointen med konstruktionen var som beskrevet i opgaven at bygge en grundlag for at monterer en “solcelle” som skulle kunne dreje sig efter solen, og dette vil vi mene at vi har fuldført med denne konstruktion.

Gearing:

Vores tanker men denne gearing var, at da vi først så hvor mange omdrejninger at motoren kørte med, tænkte vi at den skulle nedgears en del for at få omdrejningerne som motoren producerer ned til et niveau som vil være brugbart for vores “solcelle”. Måde hvorpå vi har opbygget den her gearing er ved at ved at tage et lille tandhjul som overfører omdrejninger til et stort/større tandhjul. Ved at gøre dette får vi det store tandhjul til at køre men det laver omdrejningstal en det lille tandhjul. Vi har efterfølgende placeret en spiral for at kunne roterer drejningsmomentet 90˚. Vi har derefter placeret et stort tandhjul med en vandret orientering som modtager omdrejninger fra spiralen og videreføre det via en lodret akse til vores sidste gearings element.

Den mekaniske gearing vi fik lavet til vores solcelle platform

Da vi byggede vores platform og derved også gearingen, før vi blev universitetet blev lukkede nåede vi ikke at teste det i forbindelse med de elektroniske komponenter, og derfor er vores gearing måske ikke den helt optimale til vores system. Men ud fra de forudsætninger vi nu havde har vi regnet omdrejnings forholdet ud for den gearing vi fik lavet. Vi fandt et data sheet over de forskellige tandhjul brugt i gearingen og har derefter regnet forholdet ud.

Forholds beskrivelse mellem forskellige typer tandhjul

Ud fra denne har vi fundet omdrejnings forholdet mellem vores forskellige tandhjul og regnet det totale forhold ud for hele vores gearing.

3:1*3:1*40:1*2,25:1 = 810:1

Vi har prøvet at finde tal for hvor mange omdrejninger vores DC motor leverer men har ikke kunne finde konsensus omkring dette, derfor har vi taget et udgangs punk for udregningerne og brugt 250 RPM da det var det tal der gik mest igen i vores søgning. Med dette i mente har vi lavet en udregning for hvor mange omdrejninger vores “solcelle” ville tage på et døgn.

1/810=0,00123

Solcellen hastighed = 250*0,00123 = 0,3075RPM

Omgang pr. døgn = (60*24)*0,3075 = 442,8 RPD

Dette er selvfølgelig udregner med udgangs punk i at motoren leverer med fuld effect hele tiden.

Kredsløb:

Kredsløbet består af en H-bro med en motor, et spændingsregulator kredsløb, et LED kredsløb og to LDR kredsløb. H-broen er dimensioneret efter at lego-motoren, som hedder Lego Power Functions Large Motor, holder til 9v[1,2]. Derudover har motoren en stall current på 450 mA[3]. 

  • Rød boks: Denne del af kredsløbet indeholder H-broen (Figur 1)
  • Orange boks: Denne del indeholder spændingsregulatorkredsløbet (Figur 1)
  • Gul boks: Denne del er LED kredsløbet (Figur 1)
  • Grøn boks: Denne del er en af to identiske LDR kredsløb (Figur 1)

Komponenter på diagrammet (Figur 1)

Q1 og Q2 er P-channel enhancement MOSFET transistorer (IRF9520):

  • Gate Threshold Voltage er mellem -2v og -4v
  • Maksimal Gate til Source Voltage er 20v
  • Holder til op til 200v og mellem 9A
  • Diode Source til Drain Voltage er -1,5v
  • Maksimal vedvarende Source-Drain Diode ampere er -6A

Q3, Q4 og Q5 er N-channel enhancement MOSFET transistorer (IRF630):

  • Gate Threshold Voltage er mellem 2v og 4v
  • Maksimal Gate til Source Voltage er 20v
  • Holder til op til 100v og 6A
  • Diode Source til Drain Voltage er 2v
  • Maksimal vedvarende Sorce-Drain Diode ampere er 9A

M er en DC motor (Lego Power Functions Large Motor)[1,2,3]:

  • Max spænding: 9v
  • Stall current: 450 mA

R6 er en lysmodstand:

  • Høj belysning: 50 ohm
  • Svag belysning: 55 kOhm

R1-R5 er helt admindelige modstande.

C1 er en polariseret kodensator.

Arduino Uno[6]:

  • Pin output: op til 5v
  • Strømstyrke på pins: 40mA

Hvordan er h-broen opbygget inkl begrundelser og beregninger?

Alle betegnelser referere til figur 1

Først of fremmest kræver H-broen at transistorerne Q1-Q4 holder til de ampere og volt som leveres til moteren mellem drain og source, og eftersom de to typer transistorer holder henholdsvis 100v og 6A og 200v og 9A, som er væsentligt mindre end de værdier, der leveres til motoren (9v, 0,480A), er transistorerne ikke i risiko for overbelastning.

Q1 og Q2 er P-channel transistorer, som lader en strøm gå fra source til drain ved en positiv spænding mellem gate og source. Omvendt er Q3 og Q4 N-channel transistorer, som lader en strøm gå fra drain til source ved en negativ spænding mellem gate og source. Derved vil en positiv spænding fra arduinoen på pin 9 skabe en spændning fra gate til source på Q1 og Q3, og dermed tænde Q1 og slukke Q3. Omvendt på den anden side med 0v fra pin 8, vil Q2 være slukket og Q4 vil være tændt på grund af en negativ spænding mellem gate og source, der nu

er negativt ladet, på grund af en positive spænding mellem drain og source på Q4. Dermed vil strømmen løbe igennem Q1 og Q4 og videre til spændingsregulatoren ved Q5.

Spændingsoutputtet fra pin 8 og 9 ligger på 5v, og eftersom transistorene Q1-Q4 afhængigt af temperatur lukker 0,5 til 1A igennem ved 4,5v, er spændingen fra strømforsyningen ikke begrænset i H-broen.

R1 og R2 er pull-down modstande, som har til formål at konstant sikre en lille strøm til gates på transistorerne Q1-Q4, og det er vigtigt, når vi arbejder med MOSFET transistorer, fordi de er særligt skrøbelige på deres gates og kan brænde af med forholdsvis små strømme på gaten sammenlignet med andre transistorer. Dette undgås ved størrelsen af modstandende, som derfor ligger på 10 kOhm.

Når motoren slukkes, vil der være oplageret en induktiv energi i batteriet, som ved konvertering til strøm vil opstå, opstå som et højt peak af spænding i modsatte retning. Derfor er der placeret dioder parallelet med transistorerne Q1-Q4 i modsatte retning så energien løber tilbage og over transistorerne og ikke igennem dem. Hvis strømkilden er et genopladeligt batteri vil dette peak oplade batteriet en smule, men strømforsyningen kan også være et ikke opladeligt batteri, og et induktivt peak i spænding kan potentielt være for høj til, hvad et batteri kan håndterer. Derfor er C1 placeret mellem strømforsyningen og jord lige inden H-broen, så denne kondensator fanger peaket og aflader denne i jord istedet. Hvis dette kredsløb havde været samlet i virkeligheden ville vi ikke placerer disse dioder over transistorerne Q1-Q4, fordi de pågældende transistorende allerede har dioder mellem source og drain. Det er medtaget i kredsløbet, fordi MOSFET transistorende i tinkercad ikke har disse dioder integreret.

Arduinoen er connected til gates på transistorerne via 2 pins, og når den ene pin outputter skal den anden ikke have output. Outputtet skal være mellem 2v og 4v for at aktivere gates på transistorene, så f.eks. Når dette outputtes fra pin 9 i diagrammet løber strømmen med de grønne pile på diagrammet.

Hvordan er spændingsregulatorkredsløbet opbygget inkl begrundelser og beregninger?

Alle betegnelser referere til figur 1

Spændingsregulator kredsløbet er opbygget af en N-Channel enhancement MOSFET transistor ligesom i H-Broen. Ligesom transistorerne Q1-Q4 i H-broen, lukker Q5 en strøm igennem på mellem 0,5A og 1A, afhængigt af temperatur, ved en spændingsforskel på 4,5v mellem source og gate (se figur 2). Dette passer godt med arduinoens output på 5v, og worst case current fra motoren på 0,48A. Derudover kan vi også se på figur 2, at drain-to-source voltage ved 4,5v på gate kan opnå 9v, hvilket er den spænding, som motoren maksimalt skal kunne bruge. Et spændingsoutput mellem 0 og 5v fra arduinoen vil derfor tilsvarende lukke en større eller mindre mængde strøm til jord og dermed begrænse eller lette strømmen gennem hele kredsløbet. Derved øges og sænkes hastigheden på motoren.

Derudover er der en pull-down resistor fra gate til source på Q5, for igen at mindske strømmen på gaten på transistoren Q5 ligesom Q1-Q4. Denne transistor bruges så til at regulere spændingen via arduinoen, som er connected til gaten på Q5, der outputter via PWM.

Hvilke sensorer er benyttet og hvor er de fysisk placeret på robotten.

Alle betegnelser referere til figur 1

De primære sensorer på robotten er lys modstandene R6, som drejningen af platformen baseres på. For at opnå højst mulig indtag af sollys fra solcellerne, skal lys de to R6 lysmodstande ligge i plan med og pege i samme retning som solcellerne, men placeres på hver side af solcellen horisontalt for at promovere en lys forskel på de to sensorer.

Som det ses på figur 1 er kredsløbet for en af disse sensorer bestående af et 5v output fra arduinoen ind i lysmodstanden R6, så et knudepunkt som derfra fører ind i input på arduinoen og så en modstand R4, som går i jord. R4 er en spændingsdelermodstand. For at kunne måle modstanden over R6 skal vi have en modstand i serie, for at vi så kan måle spændingsfaldet over R6 ved input i Arduionoen. Derved kan vi bruge formlen for spændningsdeler til at udregne spændingen over lysmodstanden og derved mængden af lys, der modtages.

R6 har jo maksimal modstand på 55KOhm og minimum modstand på 50 ohm afhængigt af modstand, og jo højere spændingsdelermodstanden R4 er, jo mindre bliver spændingen over R6. Vi vil gerne opnå fuldt spændingsfald i kredsløbet, så derfor skal R4 og R6 til sammen have et spændingsfald på 5 volt over sig. Derved kan vi udregne mængden af ohm i hele kredsløbet:

R4+R6 = 5v / 40mA = 1250 ohm

For at udregne den rette størrelse for R6, trækker vi den minimale modstand i R4 fra R4+R6, så vi altid opnår 1250 ohm i hele kredsløbet og 5v spændingsfald uanset størrelsen af R4:

R4 = 1250 ohm – 50 ohm = 1200 ohm

Derudover er der en aktuator på robotten, en LED, som har til formål at lyse op, når det bliver nat, på den side af platformen, hvor solen står op. Denne er dimensioneret efter 20mA output fra arduino pin2 med 5V og derfor er der brug for en 150 ohm modstand for at få spædningen ned på de 2V, som LEDen trives i.

Har det været problemfrit at opbygge robotten eller har den ændret form/sensor-placeringer flere gange?

Da vi ikke har kunne samle robotten grundet COVID-19 omstændighederne, er vi ikke stødt på nogle konstruktionsmæssige udfordringer. Det har dog været udfordrende at tænke over, hvordan robotten skulle opbygges, når vi ikke har kunnet samle kredsløbet med lego konstruktionen, og der er mange faktorer, som plads på konstruktionen osv, som kan være svære at forestille sig uden at sidde med det elektroniske kredsløb fysisk også.

Virtuelt har det været udfordrende at samle kredsløbet, fordi mange komponenter såsom MOSFET transistorer, dioder og DC motor i TinkerCAD ikke kan tilpasses, f.eks. Threshhold voltage på transistorerne og stall current for DC motoren, og disse informationer er heller ikke synlige. Derfor er kredsløbet i TinkerCAD ikke 100% dimensioneret efter de komponenter, som skulle have været brugt i virkeligheden.

Derudover har det også været udfordrende at genindstille platformen ved nattid, eftersom en DC motor ikke er bygget til at dreje til en bestemt position, men at drive noget fremad. En servomotor uden omdrejningsbegrænsninger havde været optimal for en solcelleplatform, der skal følge solen.

Hardware:

Hvordan er robottens hardware sammensat?

Robottens hardware er bestående af elektronikken og mekanikken. Mekanikken er sammensat i LEGO og elektronikken er sammentsat i TinkerCAD. De komponenter som vi ville sammensætte solcelle platformen med er:

  • 1x LEGO Power Functions Large DC motor[1,3]
  • 2x P-Channel MOSFET transistor[4]
  • 3x N-Channel MOSFET transistor[5]
  • 2x LDR (lysmodstand)
  • 1x Arduino Uno
  • 3x 10K modstand
  • 1x 1.2K modstand
  • 1x 150Ω modstand
    • Min. modstand: 50Ω
    • Maks. modstand: 55K
  • 1x Standard rød LED[7]
  • 1x Polariseret kondensator[8]

Har der været nogle problemer i forhold til at få hardwaren til at virke?

Eftersom vi ikke har siddet med hardwaren ud over lego konstruktionen, har der ikke været nogle problemer. Derudover har det været udfordrende at forestille sig, hvordan det hele skal samles fysisk, når vi ikke sidder med et fysisk kredsløb til vores lego-konstruktion.

Kode:

Hvad er de overordnede opførsler / metoder for robotten

Vi har implementeret tre fundamentale adfærer for robotten: TURN_LEFT, TURN_RIGHT og STOP. Disse actions bestemmer, hvordan solcelleplatformen skal interagere med dens omgivne miljø.

Hvordan er robottens opførsel implementeret.

Disse adfærer bestemmes ud fra mållinger fra de to lysmodstande, der måler lysstyrken i det omgivne miljø og drejer til højre eller venstre (med uret eller mod uret), afhængigt af om, der er lige meget lysstyrke på begge lysmodstande. Hvis begge lysmodstande modtager samme mængde lys, så stopper drejeplatformen med at køre rundt.

Hvis lysstyrken er under en foruddefineret tærskel på begge lysmodstande i et specificeret antal cyklusser, så går platformen i reset mode. Antallet af cyklusser og tærsklen skal kalibreres til nattetidsbelysning i det omgivne miljø. I reset mode tændes der en LED, som fysisk skal placeres på den side af solcellen, hvor solen står op. Så drejer platformen indtil lysstyrken er over tærsklen og lige stor på begge lysmodstande. så platformen peger i den rigtige retning til næste morgen. Derefter slukkes LEDen og så venter platformen indtil lysstyrken på lysmodstandene er over tærsklen igen, hvilket definere dag. Herefter køres den normale cyklus igen. Cyklusserne er kører i et tidskontrolleret loop, så omdrejningen af platformen sker jævnt.

Robotten kunne også indstilles til start position med en switch, hvor platformen drejer den modsatte vej ved nattetid, indtil den rammer en switch. Denne løsning har vi valgt ikke at gå med, fordi solens opgangspunkt på himlen ændrer sig i løbet af året, og det er nemmere at flytte en LED end en knap, på grund af den fysiske kontakt mellem platformen og knappen.

Kode + beskrivelse

// defines variable names for the used arduino ports
#define clockwise 8
#define counterClockwise 9
#define photoResistorA A0
#define photoResistorB A1
#define voltageRegulator 6
#define LED 2

// defines the fundamental actions of the platform
enum Action {
  TURN_LEFT, TURN_RIGHT, STOP
};

// declares an action object for the solar panel platform
Action action;

// scale from 0 to 255 where 0 is still and 255 is max velocity
int motorSpeed = 255;

// light inputs on a scale from 0 to 1023 where 0 is less and 1023
// is more
int lightInputA = 0;
int lightInputB = 0;

// the threshold of light at night time, this needs to be calibrated
// with the actual light in the physical product
int lightInputNightThreshold = 200;

// the cycle counts which the light resistors is allowed to be under
// the threshold of the of the light input
const int cycleCountsBeforeReset = 10;

// the cycle counts of which the light resistor is under the
// threshhold of the light input
int cycleCount = 0;

// the max amount of cycles to calibrate in order to avoid the platform
// turning back and forth for a neglible amount of light input
const int calibrationThresholdCycles = 20;

// the cycle counts of the platform returning to its default state
// for the next day
int calibrationCycles = 0;

// sets the desired time for a single cycle, and for the time the
// motor should do its action in milliseconds
const long CYCLE_TIME = 2000;
const long MOTOR_TIME = 1000;


void setup() {
  // sets up analog in at 9600 bits per second
  Serial.begin(9600);
  
  // sets up output for controling the direction and speed of motor
  pinMode(clockwise, OUTPUT);
  pinMode(counterClockwise, OUTPUT);
  pinMode(voltageRegulator, OUTPUT);
  pinMode(LED, OUTPUT);
  
  // sets control ports and speed port as idle (0V output)
  digitalWrite(clockwise, LOW);
  digitalWrite(counterClockwise, LOW);
  analogWrite(voltageRegulator, 0);
  
  // sets the action of the solar panel to stop initially
  action = STOP;
}

void loop() {
  // sets timer before processing a cycle
  long startCycleTime = millis();
  
  // prints cycle count and sensor information for debugging
  Serial.print("Cycle Count: ");
  Serial.println(cycleCount);
  readLightSensor();
  writeAction();
  
  // checks if light input is under the threshhold for light input
  if (
    lightInputA < lightInputNightThreshold &&
    lightInputB < lightInputNightThreshold
  ) {
  	// checks if the cycle count is under the threshhold before reset
    if (cycleCount++ >= cycleCountsBeforeReset) {
      // resets the platform
      reset();
      
      // resets cycle count to 0
      cycleCount = 0;
      
      // wait until the sun is up
      waitTillSunlight();
      
      // run the loop from the start
      return;
    }
    
  } else {
    // if the light on the sensors is not below the threshhold,
    // don't count the cycles
    cycleCount = 0;
  }
  
  // calculates the processing time of the cycle
  long elapsedCycleTime = millis() - startCycleTime;
  
  // sets the delay time to achieve the cycle time
  long delayTime = CYCLE_TIME - elapsedCycleTime;
  
  // if processing took longer than cycle time it is set to 0
  if (delayTime < 0) {
    delayTime = 0;
  }
  
  // set a sleep delay before repeating the next cycle
  delay(delayTime);
}

/**
/* Waits until the light on the light inputs exceeds the treshold
/* In other words, wait till the sun is up
*/
void waitTillSunlight() {
  // run a while loop the only condition that the light input
  // exceeds the threshhold of light input
  while (
    lightInputA < lightInputNightThreshold &&
    lightInputB < lightInputNightThreshold
  ) {
    // reads the light input from both sensors
    lightInputA = analogRead(photoResistorA);
    lightInputB = analogRead(photoResistorB);
    
    // waits a bit before starting the next iteration
    delay(CYCLE_TIME);
    Serial.println("Sleeping...");
  }
}

/**
/* Reset the platform, return it to the position where it is
/* pointed towards the sun when it comes up the next day
*/
void reset() {
  // turns on the LED that leads the platform into position
  turnOnLED();
  
  // make sure the platform is pointed towards the LED before
  // calibrating the position of the platform
  while (
    lightInputA < lightInputNightThreshold ||
    lightInputB < lightInputNightThreshold
  ) {
    // sets the platform action to left or counter clock wise
    action = TURN_LEFT;
    
    // do the platform action
    writeAction();
    
    // reads the new input values of the light sensors
    lightInputA = analogRead(photoResistorA);
    lightInputB = analogRead(photoResistorB);
  }
  
  // calibrates the position of the platform until the platm
  // is pointed directly towards the LED and the calibration
  // cycle threshold is not exceeded
  while (
    action != STOP &&
    calibrationCycles++ < calibrationThresholdCycles
  ) {
    // prints information of cycles for debugging purposes
    Serial.print("Calibration cycles: ");
    Serial.println(calibrationCycles);
    
    // determine the next platform action based on light input
    readLightSensor();
    
    // do the platform action
    writeAction();
  }
  
  // turns off the LED that leads the platform into position
  turnOffLED();
  
  // resets the calibration cycles to 0
  calibrationCycles = 0;
}

/**
/* Turn on the LED that leads the platform towards the sun
/* to when it comes up the next day
*/
void turnOnLED() {
  // output 5v and 20mA to the LED
  digitalWrite(LED, HIGH);
  Serial.println("Turning on LED...");
}

/**
/* Turn off the LED that leads the platform towards the sun
/* to when it comes up the next day
*/
void turnOffLED() {
  // output 0 v to the LED
  digitalWrite(LED, LOW);
  Serial.println("Turning off LED...");
}

/**
/* Updates the state of light in the environment based on input
/* from the light sensor
*/
void readLightSensor() {
  // the light input on a scale from 0 to 1023
  int lightReadingA = analogRead(photoResistorA);
  int lightReadingB = analogRead(photoResistorB);
  
  // prints old and new light input readings in this cycle for
  // debugging purposes
  Serial.print("Old reading A: ");
  Serial.print(lightInputA);
  Serial.print("\t New reading A: ");
  Serial.println(lightReadingA);
  
  Serial.print("Old reading B: ");
  Serial.print(lightInputB);
  Serial.print("\t New reading B: ");
  Serial.println(lightReadingB);
  Serial.println();
  
  // if the new sensor reading shows less light, more light,
  // or the same amount of light based on the previous reading
  if (lightReadingA < lightReadingB) {
    // turns left to follow the sun
    action = TURN_LEFT;
  } else if (lightReadingB < lightReadingA) {
    // turns right to follow the sun
    action = TURN_RIGHT;
  } else {
    // sets the action to stop in order to maintain the light
    // level
    action = STOP;
  }
  
  // updates the old reading with the new higher light value
  lightInputA = lightReadingA;
  lightInputB = lightReadingB;
}

/**
/* Decides whether to turn right or left based on the state
/* from the readLightSensor method in the current cycle
*/
void writeAction() {
  switch (action) {
    case TURN_LEFT: {
      // turns the motor counter-clockwise
    	digitalWrite(counterClockwise, HIGH);
      	
      	for (int i = 0; i < motorSpeed; i++) {
        	analogWrite(voltageRegulator, i);
          	delay(10);
        }
      
      	// wait for the amount of time the motor should turn
      	delay(MOTOR_TIME);
      
      	for (int i = motorSpeed; i >= 0; i--) {
        	analogWrite(voltageRegulator, i);
          	delay(10);
        }
      
      	// stop turning the motor
      	digitalWrite(counterClockwise, LOW);
      	analogWrite(voltageRegulator, 0);
      	break;
    }
    
    case TURN_RIGHT: {
      // turns the motor clockwise
    	digitalWrite(clockwise, HIGH);
      	
     	for (int i = 0; i < motorSpeed; i++) {
        	analogWrite(voltageRegulator, i);
          	delay(10);
        }
      
      	// wait for the amount of time the motor should turn
      	delay(MOTOR_TIME);
      
      	for (int i = motorSpeed; i >= 0; i--) {
        	analogWrite(voltageRegulator, i);
          	delay(10);
        }
      
      	// stop turning the motor
      	digitalWrite(clockwise, LOW);
      	analogWrite(voltageRegulator, 0);
      	break;
    }
    
    case STOP: {
      // keeps the platforms position
      digitalWrite(clockwise, LOW);
    	digitalWrite(counterClockwise, LOW);
      analogWrite(voltageRegulator, 0);
    }
  }
}

Hvilke udfordringer har der været ift. til at få koden til at virke?

Det har været besværligt at implementere funktionalitet der tager højde for nat og dag, når der ikke arbejdes med en servo motor, som kan sættes til den præcis samme position baseret på et input. Derfor har vi valgt at bruge en LED som pejlemærke, og denne LED peger derfor i den retning solen er ved solopgang.

Video fra TinkerCAD:

https://www.dropbox.com/s/dv7h05ngxvzmj97/kredsl%C3%B8b.mov?dl=0

TinkerCAD:

https://www.tinkercad.com/things/aEviKgPUbJL-endeligt-hardware-solcelle/editel?sharecode=6Lf9p-nIpFzRxrt3j5p0rB3j4Tn7NX-mZuEG3AdwjKg

Konklusion 

Robotten løser opgaven fint. Ud fra hvilken position solen har på himlen vil vores robot ændre hvilken retning “solcellen” vende. Der bliver igennem kode taget højde for, om der kunne være eventuelle skure, der driver ind foran solen, før at der bliver lavet en korrigerende handling om at dreje “solcellen”. Platformen vender derudover tilbage til startposition mod solopgang ved nattetid og venter der, indtil solen står op. Solcellen er også kalibreret til en omdrejningshastighed, der passer til solens hastighed over himlen og påkrævet hastighed for at nå til startposition i tide inden solopgang. Ideer til videreudvikling af platformen kunne være at implementere en varierende omdrejningshastighed fra DC motoren baseret på deltalysinputtet mellem de to lysmodstanden, så den tilsvarende omdrejning af platformen er beregnet til den rette position, frem for at køre frem og tilbage.

Referencer:

  1. https://www.amazon.com/Lego-Power-Functions-L-Motor-88003/dp/B00G9YU3TY
  2. https://www.philohome.com/motors/motorcomp.htm
  3. https://www.lego.com/en-us/themes/power-functions/element-spec
  4. http://pdf.datasheetcatalog.com/datasheet/fairchild/IRF9520.pdf
  5. https://www.vishay.com/docs/91031/sihf630p.pdf
  6. https://lh3.googleusercontent.com/proxy/hFs8gOpzWkd3jRN6RaISyopB0IIwIqvR9GPUuCrl157cfCJBeMEFaYHjWWtKsYEh52JgfEBUpxzdlHIcOW18bXQoTgDXqRdEtW3ztEkJFIF8W6CC7thiRyo?fbclid=IwAR1eVA04PhLgMd63iwHcQ1hnN8VWyL5dWwxmSWB4EsuUDmYThM99HHlN57c

Leave a Reply