Senõr Sun Chaser

Lavet af: Mickas Louis Jensen & Magnus Rømer

Ingen tilgængelig beskrivelse.

Hardware liste:

  • Arduino
  • Servo motor
  • 2 x LDR sensor
  • 2 x 10k ohm resistor
  • Pap
  • Ståltråd
  • Breadboard

Tanker bag om systemet

Vi fik til opgave at lave et system der kunne justere placeringen på en “solcelle” så den fulgte solens gang og dermed fik det bedste udbytte af den tilhørende “solcelle”. Da vi fik etableret at vi skulle bruge en meget lille servo motor der var inkluderet med vores arduino start-kit, vidste vi med det samme at vores konstruktion var nødsaget til at være bygget af et let materiale. Vi tænkte straks at vi ville bruge en masse af det pap vi fik tilsendt med alt vores andet grej og bruge dette som et stativ til vore solcelle.

Første design

Vi delte derfor en Amazon kasse i halv og brugte den ene halvdel til at huse vores hardware og toppen af kassen som før var låg kunne bruges som en “vippe” vi kunne have solcellen på som derefter kunne vippes efter hvor solen er ved hjælp af servomotoren. Til denne konstruktion havde vi så tilføjet en lyssensor på toppen af låget og en lyssensor i bunden. Motoren var placeret i bunden af papkassen som dertil havde en ståltråd hængende fast. Denne ståltråd hev fast i toppen af lågen og dermed lukkede kassen og solcellen lå på en fin vippe der kunne følge solen. 

Efter opbygningen af denne opstilling fandt vi ud af at det ikke var muligt for servomotoren at lukke lågen helt, dette gjorde løsningen ufuldstændig. Vi blev derfor nød til at revurdere vores opbygning og måtte tilbage til start.

Billede 1: Første design
Link til video af første design: https://drive.google.com/file/d/1KeQjxiLJk5gh0b5XvZKkqBTiuQORfDEm/view?usp=sharing

Andet design

Dette design har et stykke pap sat fast til servomotoren som så drejer sig efter hvor solen er. Der er en sensor på hver side som kan måle lysstyrken og signalere servomotoren om hvilken retning der skal drejes. Grundlaget for dette design var at vi gerne ville fjerne så meget eksternt støj som vi kunne, og kun fokusere på kernen af hvad vi gerne ville opnå, hvilket er at få skabt et apparat der kan hjælpe en solcelle med at følge solen. LDR sensorene er placeret yderst på hver side for at sensorene opfanger to forskellige værdier. Da vores “solcelle” hurtigt kom til at veje mere end vores servomotor var vi nødsaget til at tænke hurtigt og stripse motoren fast til noget stabilt.

Billede 2: Andet design
Link til video af andet design: https://drive.google.com/file/d/1At6guPZ_mfCPU2VSLg_9chXMeuZMeRI3/view?usp=sharing

Problemer med design

Vi havde en del problemer med at få designet noget der reelt kunne følge solen, men da vi skruede det helt ned til det aller mest basiske blev det muligt for os at finde en løsning. Vi havde dog en del problemer med holdbarheden af vores konstruktion og kan derfor ikke anbefale at man benytter den udendørs.

Hardware sammensætning

Hardwaren har vi designet ved hjælp af TinkerCad, dette blev program blev brugt da det gjorde det nemmere at arbejde på afstand og gøre det klart for andre medlemmer i gruppen hvad ens tanker er uden man behøver at hive alle ledninger frem og begynde at bygge. Vi kom frem til et endeligt simpelt design som kan ses forneden.

Billede 3: Diagramtegning af hardwaren tegnet med TikerCad

Vi har tilføjet lavet et flowchart over de stadier vores system gennemgår. Når systemet bliver tændt nulstiller servomotoren sig selv, dernæst begynder programmet at tjekke lysdifferencen mellem de to LDR sensorer. Hvis den er over 10 justere “solcellen” sig. Hvis den ikke er over 10 bibeholder den sin position. Vi har også tilføjet et delay på et minut før den igen tjekker lys differencen. Dette er gjort da det ikke er nødvendigt at tjekke om solen har rykket sig hver nano sekund. Hvert minut er også ret hurtigt, men dette gjorde det muligt for os at samle nogle flere test tal. Det gjorde det også nemmere for os at se visuelt om vi havde gjort det rigtigt.

Vi havde også tænkt hvad vi ville gøre med systemet når solen den går ned, dette problem går i sig selv da vores system ikke bevæger sig hvis der ikke er nogen sol at justere sig efter. Den venter bare indtil der er en sol difference den kan finde.

Billede 4: Flowchart af systemets stadier

Kodning

Billede 5: koden til vores system

Vi har lidt forskellige variabler i vores kode som vi i dette afsnit vil gennemgå:

  • Først har vi startServo denne sørge for at motoren starter i den rigtige position før den begynder at samle data fra de to LDR sensorer.
  • Dernæst har vi eVal og wVal disse variabler er til at samle data fra de to LDR sensorer. Denne værdi kan derefter bruges til forskellige funktioner i vores system.
  • Herefter kommer diff som samler forskellen mellem de to LDR sensorers værdier, hvis forskellen er tilstrækelig høj signalere den til motoren at den skal skifte position. Det er vigtigt vi har denne værdi så motoren ikke rykker sig konstant.
  • checkVal1 og 2 er den værdi som vi har valgt skal være grænsen for hvornår motoren skal reagere og begynde at bevæge sig efter hvor der er mest sollys.
  • sunVal dette er værdien vi har målt til at være den værdi LDR sensoren minimum skal registrere for at der er sol på himlen.

Kodningen gik generelt fint, og det var ikke her vi fandt de store problemer. Vi troede engang at det var koden den var gal med, men det viste sig at være hardware fejl på to af vores servomotore.

Graf

Vi forsøgte os med at udøve en reallife test af vores system. Dette resulterede desværre i at vi fandt en fejl, vores LDR sensorer var ikke langt nok fra hinanden så derfor rykkede vores solcelle sig ikke i de ~9 timer den havde været tændt. Tilmed skal det tilføjes at lejligheden hvor systemet blev testet har kun vinduer mod den vestlige side og vi testede om morgenen så der var heller ikke meget sol at hente der. Halvvejs inde i testen opdagede vi også at vinduet var dækket af et halvtag, det havde ikke nogen effekt på testen da vores fejl med sensorene stadig var et problem.

Billede 6: Resultat af reallife test (test startet 6:47, test sluttet 15:34.
Billede 7: Billede af lejligheden der blev testet i oppefra. Rød cirkel markere lejligheden.

Konklusion

I det sterile test miljø hvor vi selv står med lyskilden virkede vores system efter kravspecifikationerne, dog efter test i et virkeligt scenarie viste der sig at være nogle designfejl der påvirkede det endelige resultat i forhold til at følge solen, da sensorerne sidder for tæt og dermed kommer forskellen mellem de to til at være for lille til at den vil ændre vinkel. I forhold til en virkelig skala af modellen ville dette dog ikke være et problem, da så ville afstanden være lang nok til at der ville komme en betydelig forskel på de to sensorer. En mulig løsning til vores model skala, ville dog være at sætte et stykke pap imellem de to sensorer for at skabe skygge, der tvinger den til at ændre til den rigtige vinkel for at få det mest optimale udbytte af solen.

More

Boogie Bim Bim

Andreas Adriansen, Freya Arbjerg, Osman Khassouk

Designvalg

Gruppen har valgt at benytte sig af følgende komponenter:

  • 2x LED’er, henholdsvis grøn og rød
  • 2x 220 ohm resistorer
  • 2x 10k ohm resistorer
  • 2x LDR modstande
  • Servomotor
  • Arduino

Nedenunder kan opsætningen ses både i tinkercad og i form af sketching.

Lysdioder
En LED (light-emitting-diode) er en halvlederlyskilde, der udsender lys når strøm kommer igennem den. Elektroner i halvlederen rekombineres med elektronhuller og frigiver energi i form af fotoner. Der er i dette projekt gjort brug af en grøn og rød lysdiode som har til formål at vise status på robotten. 

Resistor
En resistor er en passiv to-terminal elektrisk komponent, der har til formål at implementere elektrisk modstand som et kredsløbselement. Den benyttes ofte i kredsløb til at opdele spændinger, juster signaler reducere strøm mængden og meget mere. I dette tilfælde er det blevet anvendt i sammenkobling med lysdioderne og photoresistorene for at formindske mængden af strøm som løber igennem dem.

Photoresistor
En LDR (light-dependant-resistor) er en passiv komponent som formindsker modstanden baseret på den lysstyrke den modtager på overfladen. Modstanden på en photoresistor falder når lysintensiteten stiger og er opnår sin maksimale modstand når det mørkt. Dens lysfølsomhed bliver derfor anvendt som en sensor der i dette projekt kontrollere om robotten skal dreje eller stå stille.

Servomotor
En servo er en aktuator som består af delene DC motor, en gearing, ene styring og en positionssensor. Servoer kan styres meget nøjagtigt og kan placeres i forskellige vinkler, ofte mellem 0 og 180 grader. Den bruges i projektet til at rotere robotten baseret på de opsamlet sensorværdier fra photoresistorne.

De to LED’er skal fungere som status signaler. Den røde indikerer at servomotoren er i bevægelse, hvilket betyder den justerer sig efter hvor lyset er. Den grønne LED er tændt når motoren er på standby, hvilket betyder at solcellen er i den optimale position.

De to LDR modstande står for at indsamle data der kan fortælle noget om hvor lyset er stærkest. Deres værdier sammenlignes for at vurdere dette.

Til sidst har gruppen benyttet sig af en servomotor. Servomotoren kræver ingen form for gearing eller ekstra strømforsyning, da den kan køre på de 5V arduinoen udleder. Servomotoren er dog en smule begrænset i forhold til den stillede opgave, da den kun kan rotere 180 grader. Af denne grund skal systemet opsættes optimalt således at den opfanger så meget lys som muligt.

Robotten er konstrueret ud af en papkasse. Lim og isoleringstape er blevet brugt til at sætte servoens roterende del sammen med den ene halvdel af papkassen. Denne del af papkassen der tapet sådan at den har en vinkel på ca. 45 grader. Den anden del af papkassen er limet til bunden af servomotoren for at sænke robottens tyngdepunkt og gøre den mere stabil. 

Beregninger

Resistorerne for lysdioder er blevet beregnet efter spændingsfaldene på de enkelte lysdioder. Da den grønne lysdiode har et spændingsfald på 2,2 V og strømstyrke på 25 mA, kan ohms lov bruges til at beregne formodstanden.


Det samme bliver gjort for den røde lysdiode hvor spændingsfaldet er 2,0V og strømstyrken 25mA.

Systemets opførsel

Flowchart

Kode

De forskellige pins initialiseres. Der er opsat konstanter for de forskellige pins. Threshold værdien er den værdi der benyttes til at vurdere om der er en stor nok forskel på de to LDR modstande. Ved opstart bliver motoren nulstillet til at være på midten med en 90 graders vinkel.

Næste del af koden består af 3 metoder. rotateRight, rotateLeft og notMoving. De to rotate metoder sørger for at rykke servomotoren enten til venstre eller højre, og at sætte det røde lys til at være tændt, HIGH. Den sidste metode, notMoving, tænder det grønne lys og slukker det røde lys.

Til sidst er der loopet som bliver kaldt gentagende gange. Her aflæses værdierne af de to LDR modstande og delta udregnes. Baseret på deltas værdi vil den enten kalde rotateLeft, rotateRight eller notMoving. Det sker ved at sammenligne delta med threshold værdien.

Test

Robotten blev testet under lys fra en lommelygte. Desværre fik gruppen ikke lavet en længere test med rigtigt sollys, men følgende grafer kan stadig laves for testen med lommelygten.

I grafen ovenover ses de to sensorværdier over tid. De starter med at ligge stabilt men idet lommelygten bliver benyttet begynder værdierne at svinge. Lygten flytter sig flere gange under testen.

Her ses motorens position over tid. Ligesom i grafen før, så begynder værdien først at ændre sig når lommelygten bliver brugt og sensor værdierne skifter. 

Demo kan ses på linket nedenunder.

https://drive.google.com/file/d/15ZzWt-TcGYLM9kUUwWKXGwBwszm9Y_eu/view?usp=sharing

Konklusion

Det kan nu konkluderes at gruppen har dannet kendskab til det at skulle opsætte et kredsløb ud fra en opgavebeskrivelse. Gruppen har arbejdet med designvalg og diskuteret forskellige løsninger før den endelige løsning kom til. I løbet af projektet har gruppen lært at benytte servomotoren og LDR modstande for at til sidst at kunne lave et produkt der kan justere sig efter solens position. Desværre fik gruppen ikke formået at få lavet udendørs test over længere tid og dette måtte udskiftes med en simplere indendørs test med lommelygte. Mulige forbedringer kunne være at bygge robotten ud af bedre materiale, brug af PCB og en anden motor der kan rotere hele vej rundt.

More

SortSol 1.0

Nils Vestergaard Lauritzen Niklas Rosendahl Arnesen

Opbygning:

Kravet for denne opgave var at “Konstruere en solcelle styring, der drejer en solcelle efter solens lys med en motor for at optimere udnyttelse af solens energi”.

Vi gik til denne opgave med udgangspunkt i et simpel design som kan opfylde opgavens krav. Vi gik med at konstruerer robottens “skelet” ud af pap og tape, da det var de materialer vi havde til rådighed. På billede 1 og 2 er illustreret vores skitsering af robotten. Da vores robot kun roterer i en akse gav det mest mening for os at fladen med photoresisterne var vinklet 45 grader. Vi vil mene at dette ville være den mest optimale vinkel til solen, i forhold til at få de bedste målinger. 

Robotten består som vist på tegning af en større bund, der fungerer som en balancerende fod. Inde i foden kunne vi nemt placere Arduinoen og breadboardet, og der fra trække ledninger op igennem foden til photoresisterne og LED’erne. Oven og midt på denne fod er servo motoren placeret, hvor selve solcellen balancerer oven på motorens greb. Ideen bag dette, var at motoren roterer hele solcellen mod lyset. Da der ikke er nogen form for gearing i servomotoren var det ikke nødvendig at forholde sig til gearingen.

Set fra Siden Set fra fronten

Vi har valgt at placere photoresisterne helt ude i siderne på fladen. Det gav god mening i forhold til at de ville være nemmere at måle difference mellem de 2 photoresistorer. Som krav i opgaven skulle vi implementerer status lysdioder. Vi valgte at bruge en grøn og rød LED pærer til at indikerer hvilken status vores robots software er i når den køre. Vi valgt at placere dem på toppen af foden hvor de er tydelige at se.

Robottens grundlæggende udseende har ikke været ændret undervejs i processen. Vi valgte dog at placerer et stykke pap i midten på fladen hvor photoresisterne er placeret. Det ville medfører at robotten ville have nemmere ved at vende sig mere direkte mod solens stråler.

Robottens Hardware:

Kræsløbs diagram

Liste over anvende komponenter:

  • 1 stk: Uno R3 controller Board
  • 4 stk: 330 ohm resistorer
  • 2 stk: photoresistor
  • 1 stk: Grøn LED
  • 1 stk: Rød LED
  • 1 stk: Servo Motor
  • 1 stk: Breadbord
På billedet nedenfor ses robotten forfra, hvor de blå ringe fremviser placeringen af begge photo-resistorer, mens de røde ringe fremviser placeringen af begge LED pærer.
Det næste billede viser også placeringen af begge LED pærer, men også placeringen af motoren imellem solcellens øverste og nederst del.

Vi har ikke haft stører problemer hardware, udover små fejl med forkert placerede ledninger og komponenter.

Opførsel:

Robottens to photo resistorer måler hele tiden lysstyrken. Når robotten er sat op, tjekker den først om lysstyrken på begge photo resistorer er for lav, det vil sige at de måler om det er nat. Hvis det er nat, så roterer motoren hen til sin start position. Dette er derfor vigtigt at motoren står peget mod øst, før den er startet. I denne tilstand slukker robotten for begge dioder, for at vise det er nat. Hvis lysstyrken ikke er for lav, så sammenligner robotten begge photoresistorernes data og finder differencen imellem hver deres målte styrker. Hvis difference ikke er for stor, går koden tilbage fra start, men hvis den er for stor, så skal den roterer motoren hen mod lyset. Dioden der matcher den givne retning lyser op, mens den anden slukkes for at vise, dens tilstand. Ellers lyser begge differencen dioder op, hvis den ikke roterer.
Den bestemmer derfor retningen ud fra, hvor lysstyrken er lavest, og den roterer efterfølgende motoren indtil at differencen er en acceptabel størrelse igen.

Flow diagram over robottens opførsel
#include <Arduino.h>
#include <Servo.h>

Servo tracker; // create servo object to control a servo

// varibler for de forskellige indputs of outputs
int sensorOne = A0; //rød
int sensorTwo = A1; //grøn
int sensorDifference = 0;
int sensorOneLight = 6; //rød
int sensorTwoLight = 5; //grøn

//startpostion for servo
int sensorPosition;
int startPosition = 159;


void setup() {

  Serial.begin(9600);

  pinMode(sensorOneLight, OUTPUT);
  pinMode(sensorTwoLight, OUTPUT);
  tracker.attach(11);
  tracker.write(startPosition);
}

void loop() {
  // Mål og gem data fra begge photoresistorer
  int valueOne = analogRead(sensorOne);
  int valueTwo = analogRead(sensorTwo);

  // Mål differencen på deres lysstyrken
  sensorDifference = valueOne - valueTwo;

  // Kald "dataCollect" funktionen og print dataen i konsollen.
  dataCollect(valueOne, valueTwo);

  /* Tjek om lysstyrken er for lav hos begge photoresistorer
   *  Hvis lysstyrken er for lav, er det nat.
   */
  if (valueOne < 10 && valueTwo < 10) {
    // Roter dernæst motoren hen mod startpositionen (mod øst)
    sensorPosition = startPosition;
    tracker.write(sensorPosition);

    // Sluk for begge dioder, så det vises at det er nat
    digitalWrite(sensorOneLight, LOW);
    digitalWrite(sensorTwoLight, LOW);

  }
  else {
    /* Hvis det ikke er nat, så mål differencen.
     * Hvis differencen er for stor?
     */
    if (sensorDifference > 50)
    {
      /* Tænd den ene diode, så robotten viser hvilken retning den drejer.
       * Dernæst roterer motor indtil differencen er tilpas
       */
      digitalWrite(sensorOneLight, HIGH);
      digitalWrite(sensorTwoLight, LOW);
      if (sensorPosition < 160) {
        sensorPosition++;
        tracker.write(sensorPosition);
        delay(100);
      }

    }
    else if (sensorDifference < -50)
    {
      digitalWrite(sensorOneLight, LOW);
      digitalWrite(sensorTwoLight, HIGH);
      if (sensorPosition > 20) {
        sensorPosition--;
        tracker.write(sensorPosition);
        delay(100);

      }
    }

    else {
      /* Hvis differencen er tilpas, så tænd for begge dioder, 
       *  så det vises at robotten er i en neutral tilstand
       */
      digitalWrite(sensorOneLight, HIGH);
      digitalWrite(sensorTwoLight, HIGH);

    }
  }
  delay(300);
}


void dataCollect (int valueOne, int valueTwo) {
  Serial.print("Difference: ");
  Serial.print(sensorDifference);
  Serial.print (" - SensorOne: ");
  Serial.print(valueOne);
  Serial.print(" - SensorTwo: ");
  Serial.print(valueTwo);
  Serial.print(" - MotorPos: ");
  Serial.println(sensorPosition);
};

Test af Robot

Grundet det dårlige vejr med mangel af sol, blev vi nødt til at være lidt kreative med vores test. Derfor tog vi solcellen ind i et mørkelagt rum, hvor vi tog en lampe og førte den langsomt rundt i en bue over solcellen, for at simulere solen. Dette blev gjort over ca. 3 minutter, og resultatet kan ses på grafen nedenfor. Grafen viser hvor meget lys hver photoresistor modtager samt differencen imellem dem, og den viser også motorens position, der går fra 20 til 160 grader. Det kan tydeligt ses, at når den absolutte værdi af differencen, når over en værdi af 50, så begynder motoren at roterer.

graf over test

Det har været en udfordring at opsamle den givne data. Vi brugte et delay i vores update funktion, for at undgå at motoren drejede alt for hurtigt, og ikke rev alle ledninger ud af breadboardet, og for at den ikke opsamlede alt for meget unødvendigt data.
Vi prøvede at gøre “delay” større, så den ikke opsamlede data for hver frame, men så roterede motoren for langsomt. Fx hvis delay var 1 minut, så roterede motoren en lille smule hvert minut. Vi endte derfor med at gøre vores delay til 300 millisekunder som en nem middelvej. Ulempen ved de 300 millisekunder er dog at man ender med rigtig meget data meget hurtig. Det medførte også til at da vi testede robotten ude i solen i ca. 3 timer, endte vi med så meget data at da det skulle overøres forsvandt meget af data, og kunne ikke bruges.

Konklusion

Kort sagt fungere solcellen som den skal. Robotten måler lysstyrken gennem de to photo-resistorer, og ud fra differencen roteres robottens overflade igennem en servomotor hen mod det stærkeste lys. Når lysstyrken er lav ved begge photo-resistorer, bedømmer robotten det er nat og roterer tilbage til sin start position. Robottens status vises også igennem to LED pærer.

Robotten er fremstillet i pap, hvilket er meget ustabilt og ikke ideelt, hvis den skal placeres udenfor i længere tid. Udover dette er den også afhængig af en computer, hvor muligheden for at tilkoble et batteri til Arduinoen ville være en forbedring.

Vi kunne nok også have genovejet strukturen på vores kode og lavede nogen ændringer, så robotten eventuelt kunne køre mere optimalt, og at data mængden ikke blev lige så står når den kører. Det kunne have gavnet da vi testede fordi, vi kunne have undgået at miste meget af vores data. Ud fra dette kunne vi have sammenlignet servo motorens vinkel med solens reélle elevationsvinkel, som have været det mest optimale.

More

The Turnminator

Hardware og Robotteknologi
Foråret 2021
Porteføljeopgave 1

Lars Philip Francisco Allerup
Maria Skougaard Andersen
Rune Philipsen


Vi havde fra starten en tanke om at bygge vores system ved at lave en solfanger ud af to lysfølsomme modstande, som var placeret i hver sin side af et lille breadboard. Solfangeren placerede vi lodret ovenpå en servomoter, for at den lignede en solfanger, der kunne dreje 180 grader, fra den ene side til den anden side.

Afhængig af værdierne fra de to lysfølsomme modstande, ville vi angive hvilke vinkel og retning servomotoren skulle dreje, alt efter hvilken af de lysfølsomme modstande, der fik mest lys, for at lyspanelet hele tiden kunne stå mod solen og opfange mest lys. 
Vi byggede en simpel prototype for at afprøve vores ide og funktionaliteten. Et billede af opsætningen ses nedenfor:

Billede: Første lo-fi forsøgsopsætning

Vi arbejdede videre og i vores endelige opsætning har vi ligeledes placeret vores servomotor så den bærer vores solpanel, hvilket vi har vinklet 40 grader mod syd som ifølge EU’s photovoltaic geographical information system er den optimerede indgangsvinkel for solen i Odense.

Nedenfor er et billede af vores færdige opsætning:

Billede: Opsætning af vores endelige solfangersystem

Som det kan ses på ovenstående billede, har vi i vores endelige opsætning også implementeret en lcd skærm til at give beskeder i forhold til, om det er dag og lyst eller mørkt og nat. Derudover har vi opsat xx status-lysdioder, der lyser alt efter hvilket stadie vores solfangersystem er i.

Vores opstilling i tinkercad

LDR

For at kunne måle vores værdier fra vores to LDR-resistor hhv. den vestlige og østlige. Måtte vi opbygge et spændingsdeler kredsløb. Grunden til dette er at photo-resistoren er en variabel resistor som ændrer sin indre modstanden på baggrund af lysstyrken. For at måle denne ændring med Arduinoens Analog to Digital Converter, som omsætter forskellen i spændingen, og ikke forskellen på resistansen I LDRèn, er det nødvendigt at have et referencepunkt hvorfra man kan måle spændingsfaldet. Hvilket ville havde været fra 0 – 5 V hvis spændingsdeler kredsløbet ikke blev anvendt.

Beregninger af LED

Til beregninger af modstande i vores led signal kredsløb har vi kigget i databladet og fundet at den foreslåede strømstyrke har en værdi mellem 16 – 18 mA.

Det vi havde til rådighed, for at vi kunne finde en tilnærmelse værdig værdi, var en 330 Ω  og 220 Ω  modstand, derfra har vi lavet følgende beregninger

Her kunne vi godt have valgt at bruge 330 Ω  eller 220 Ω  modstanden. Førstnævnte vil ikke være langt fra det ønsket og sidstnævnte modstand vil give en strømstyrke som er lidt over den maksimale strømstyrke man kan have tændt kontinuert, uden at beskadige vores led.

For udfordringens skyld valgte vi at lave en parallel forbindelse, som ville resultere i en værdi som var tættere på de 17 mA. 

Hardware udfordringer 

Undervejs har der været nogle udfordringer med noget at hardwaren. Blandt andet var ledningerne ikke lange lange nok, så opsætningen væltede nemt, når servomotoren begyndte at dreje. Ligeledes har det været svært at få en platform til at passe godt på mini servo motoren, grundet vægt og vinkel fra breadboardet. Dette har vi forsøgt at løse ved at give noget modvægt i den modsatte ende af solcelle-platformen.

Derudover har vi haft lidt problematikker med, hvordan vi skulle få skjult ledningerne bedst muligt. Ligeledes var en af problemerne, hvordan vi kunne få breadboardet med vores indikator led lys skjult på en måde, så det ikke fyldte i det æstetiske udtryk.

Den største udfordring har dog været, at vores lysfølsomme resistorer var så forskellige, på den måde at den ene hele tiden opfangede højere værdier end den anden. Praktisk resulterede det i, at hvis den LDR der opfangede højest værdier var placeret i vores opstilling mod øst, ville vores solfangersystem ikke flytte sig fra startpositionen, fordi denne værdi hele tiden var større end den opfangede værdi mod vest. 

Ligeledes hvis man byttede om på de to lysfølsomme resistorer, så den LDR der hele tiden opfangede lavere værdier, var placeret mod øst, så ville servomotoren ligegyldig hvad solens placering på himlen var dreje mod vest, fordi systemet hele tiden opfangede højere værdier fra den lysfølsomme resistor mod vest og servomotoren ville hurtigt dreje fra startpositionen hele vejen over til slutpositionen. Efter samtlige test og fysiske målinger med multimeter over modstanderne og LDR’erne, kunne vi konstatere at LDR’erne havde forskellig modstand, derfor besluttede vi at bestille nogle nye bedre LDR modstande. For at være sikre på at LDRérne var relativ præcise, målte vi dem efter med mulitmeteret. Her var der er også et mindre udsving i modstanden. Dette har vi taget højde for i vores kode.

Flowdiagram og overordnet opførsel

Billede: Flow-diagram over robottens opførsel.

Vi har lavet vores program så det tager udgangspunkt i 24 timer på et døgn. Programmet kører et loop atten gange af en varighed på en time, hvor solfangersystemet er aktivt om dagen, hvorefter der er et delay på 6 timer, hvor solfangersystemet er i dvale om natten.  

I servomoterens startposition ved solopgang i øst er dens vinkel indstillet til 180 grader. Servomoterens vinkel går mod nul grader, i takt med dagen går, og solen bevæger sig hen over himlen fra øst mod vest. 

Der bliver derudover på vores LCD-skærm, om morgenen skrevet en godmorgen-besked og ligeledes en godnat-besked om aftenen.

Når den lysfølsomme modstands værdi mod vest er større end den mod øst, bliver der trukket en grad fra servomoterens vinkel. En grøn LED lyser, som indikation om at solfangerpanelet bevæger sig den korrekte vej mod vest, og en rød LED lyser hvis panelet drejer den forkerte vej mod øst. Sammenligningen af værdierne fra de to lysfølsomme modstande sker hele tiden, hvis værdien mod vest er størst drejes solpanelet en grad mod vest, og hvis værdien mod øst er størst drejes solpanelet en grad mod øst, og hvis de to værdier er ens bliver servomoteren stående i den position, fordi det betyder at solfangerne er i den optimale position, hvor begge får mest lys. Når begge får lige meget lys, lyser den røde og den gule LED.

Software udfordringer

I udarbejdelsen af vores solfangersystem havde vi to tidskrævende udfordringer. Det første var at vi ønskede at lave nogle timere i programmet til Arduinoen, så det ikke nødvendigvis skulle være tændt og sammenligne værdier fra solfangeren hele tiden. 

Det endte med, at vi undersøgte hvornår solen tidligst var oppe i Danmark og senest nede, for at lave et tidsrum i programmet hvor servomotoren kunne være i en slags dvale, før programmet kunne starte og stoppe dag efter dag.

For at tage højde for at der kan være udsving i værdierne fra vores LDR modstande, har vi valgt at indføre en grænseværdi/difference-værdi mellem de to LDR, hvor solcelle-robotten skal blive i sit passive stadie hvorefter den tjekker værdierne igen.  

Under udviklingen af solcellerobotten eksperimenterede vi med flere muligheder for at robotten var tændt i 18 timer som er det antal af solskin timer på en sommerdag og 6 timer hvor robotten ikke var aktiv.

Her prøvede vi først at lege med Arduinos timer og interupt funktion. Det startede godt med at vi fik timeren til at fungere. Glæden var dog kort for da vi satte servo motoren til og brugte Servo.h biblioteket, opstod der problemer. Her erfarede vi at den også bruger ardunios timer 1, hvilket var den timer vi havde fået til at virke. Her kunne vi så havde prøvet at få timer 2 til at virke i stedet eller andre løsninger, som eksempels nyt servo bibliotek. Vi valgte i stedet at bruge Millis() funktionen, som returnerer den tid, som arduinoen har været aktiv i ms. Denne tid kunne vi så bruge til at styre førnævnte aktiv og inaktive timer.
Vi oplevede derudover at vi i vores timer fik en forkert tid, i det at koden også brugte en smule tid på at udføre signaleringen til de blinkende led’er.

Koden

#include <LiquidCrystal.h>
#include <Servo.h>
Servo myServo;
int servoPin = 3;

const int rs = 12, en = 11, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

int ledRed = 10;
int ledYellow = 9;
int ledGreen = 8;

int startAngle = 180;
int angle =startAngle;
int lightValEast;
int lightPinEast = A0;

int lightPinWest = A1;
int lightValWest;

int lightValDifference;

long downTime = 21600000; // 6 timers downtime til ms
long upTime = 3600000; // 1 timer til ms  --> skal være op til 18 i loop


float counterForPrinter = 0;


unsigned long startMillis;  //some global variables available anywhere in the program
unsigned long currentMillis;
unsigned long period = upTime;  //the value is a number of milliseconds   <------
unsigned long previousMillis = 0; 

void setup() {
  Serial.begin(9600);
  pinMode(ledYellow,OUTPUT);
  pinMode(ledRed,OUTPUT);
  pinMode(ledGreen,OUTPUT);
  
  pinMode(servoPin,OUTPUT);
  myServo.attach(servoPin);
  myServo.write(angle);
  lcd.begin(16, 2);
 
}

void loop() {
  
  currentMillis = millis();  //get the current "time"  the number of milliseconds since the program started
  lcd.clear();          
  lcd.setCursor(4, 0);
  lcd.print("SUNSHINE");
  lcd.setCursor(5, 1);
  lcd.print("REGGAE");
  // Loop When Running Repeat Interval of 1 Hour 18 times
  for(int i = 0; i < 18; i++){
  currentMillis = millis();  
  while (currentMillis - previousMillis <= period)  //test whether the period has elapsed
  { 
  currentMillis = millis();  
 
  lightValEast = analogRead(lightPinEast);
  lightValWest = analogRead(lightPinWest);

  lightValDifference = lightValEast - lightValWest;

  counterForPrinter +=1; 
    if(counterForPrinter == 30){ 
      Serial.println("Val East : ");
      Serial.print(lightValEast);
      Serial.println();
      Serial.println("Val West : ");
      Serial.print(lightValWest);
      
      Serial.println();
      Serial.println("Val angle: ");
      Serial.print(angle);
      Serial.println();
      counterForPrinter = 0; 
    }
  
    delay(1000);  // delay for our  timer

    if(lightValDifference <=10 && lightValDifference >= -10){                  
  
     myServo.write(angle);
     digitalWrite(ledYellow,HIGH);
     delay(10);
     digitalWrite(ledYellow,LOW);
  }

  else if(lightValWest>lightValEast && angle !=0)
 {
     digitalWrite(ledGreen,HIGH);

     angle= angle-1;
     myServo.write(angle);
     delay(10);
     digitalWrite(ledGreen,LOW);
 } 
    else if(lightValWest<lightValEast && angle !=180)    
 {
     digitalWrite(ledRed,HIGH);
     angle= angle+1;
     myServo.write(angle);
     delay(10);
     digitalWrite(ledRed,LOW);
 }
 
  if(angle == 0 || angle == 180){
    
    digitalWrite(ledYellow,HIGH);
    }
      else{
        digitalWrite(ledYellow,LOW);
        }
      }
       previousMillis = currentMillis; /* updating previous Millis so it will be subtracted in the for loop -- Makes sure the loop will run every day and - should prevent overflow after ca 50 days.*/
  }

 /*Setting Night Message */
   lcd.clear();
   lcd.setCursor(6, 0);
   lcd.print("Cya");
   lcd.print("Tomorrow");
   delay(downTime);
   myServo.write(startAngle);
}

Data ved måling og Graf


Video af Turnminatoren med lommelygte


Video af Turnminatoren med rigtig sol


Konklusion

Vi har med dette projekt fået et bedre kendskab til forskellige elektroniske komponenter og fået et lille indblik i hvordan Arduinos internal timers virker. Vi har ligeledes lært hvordan en spændingsdeler kredsløb benyttes i sammenhæng med Arduinoes AC Converter og en LDR-modstand. Vi konkluderer at vi har formået at løse opgaven i og med at vi har kunne få solcellerobotten til at dreje sig efter forskellen i lysstyrke. Vi har dog i målingen og grafen, oplevet at fordi vi vælger at måle bestemte tidspunkter, så ender vi med målinger, der ikke giver helt mening, i sammenhæng med det uforudsigelige vejr i Danmark, og uligheden i LDR-modstandene.

More

Sun-inator 6000

Gruppe:

Jonas Lund – Jolun18@student.sdu.dk
Patrick Nielsen – Panie18@student.sdu.dk
Mads Emil Falkenstrøm – Mafal17@student.sdu.dk


Indledning

Sun-inator 6000 er vores svar på portfolio opgave 1. Det er en to-go size soltracker der med sit simple design kan sættes op som en plug-and-play løsning. Ved brug af en æske og en 3D printer var det muligt at opstille et lukket miljø med et tårn til at styre “solpanelet”. Der blev fra start valgt at bruge en servomotor, samt to LED’er for at illustrere hvilken tilstand robotten er i.
Projektet i sin helhed er en simulering af et solcelleanlæg, dog uden solceller, der søger efter det bedste lysindfald for at optimere mængden af strøm der kan producere. Prototypen er blevet bygget med forskellige tilstande, heriblandt; søgning efter bedste lysindfald, bevægelse til højre eller venstre og stillestående tilstand.

Billeder

Figur 3 – Robotten under udvikling

Opbygningen

De primære tanker der danner grundlag for robotten er fordelen i at den er kompakt og nem at tage med. Den overordnede arkitektur er et tårn der kan dreje 180 grader for bedst muligt at følge solens gang fra øst til vest. Selve “solpanelet” der følger solen hælder 45 grader for at optimere lysindfaldet mest muligt i løbet af dagen. På panelet er der monteret 2 photoresistorerer i hvert hjørne med nok spredning til at det er muligt at beregne forskellen i lysindfaldet der styrer servo motorens gang. Valget er servomotor kom naturligt da det gav god mulighed for kontrol af robotten, og brug af DC motor ville medfører at et gearings system skulle sættes op for at kunne fremskaffe den samme kontrol.

Komponenter

Følgende komponenter blev brugt i forhold til opsætningen af systemet:

ComponentQuantity
Arduino Uno1x
Photoresistor2x
Servo Motor1x
100 Ω resistor2x
1k Ω resistor3x
Green LED1x
Yellow LED1x
Pushbutton1x
Figur 4 – Liste af brugte komponenter
Figur 5 – Tinkercad diagram af opbygningen
Figur 6 – Kredsløbdiagramtegning af opbygningen

Flowchart

Ud Fra flowdiagrammet kan man se at robotten har 4 forskellige tilstande, efter start af robotten vil den lede efter bedste lysindfald for begge LDR-sensorer, derefter vil robotten køre igennem, indtil robotten enten går imod højre eller venstre, alt efter hvilken LDR-sensor modtager mest lysindfald.
For at imødekomme muligheden for at repositionere robotten, er der tilføjet en knap som igen vil trigger metoden til at finde bedste lysindfald. Løbende vil robotten også tænde LED’er til at give indikatorer for om  den er tilfreds med positionen lyser den grønt, når den er i gang med at finde bedste position blinker den orgorangeange, eller når den drejer efter solen lyser den konstant orange.

Figur 7 – Flowchart af robottens opførsel

Test

Vi gennemførte en testkørsel af systemet over en tid på ca. 4 timer. Da himlen var overskyet hele dagen var lyset meget diffus og robotten havde aldrig opfattet at lysindfaldet var højere på en side end den anden udover tolerancen.
Der kan tydeligt ses en fejl i opfatningen efter ca. en tredjedel af tiden, hvor begge photorisistorer melder en signifikant mindre lysinfald. Robotten drejede sig 5 grader pga. denne fejl, men vendte straks tilbage til dens oprindelige position, hvor lysindfaldet var mere optimalt.

Figur 8 – Graf af lysindfald og servo positionen
Video 1 – The incredibly useless timelapse of the test

Kode

#include <Servo.h>

Servo servo;

//Define pins (photoRes2 pin2 is Analog, while the buttonPin 2 is digital)
const int servoPin = 9;
const int photoRes1 = 1;
const int photoRes2 = 2;
const int okLedPin = 11;
const int workingLedPin = 12;
const int buttonPin = 2; 

//Define constants
const int tolerance = 35; //Needs to be adjusted in production
const int stepSize = 5;
const int maxpos = 180;
const int minpos = 0;

//Initialize variables
int startPos = minpos;
int lightVal1;
int lightVal2;
int pos;

void setup() {
  Serial.begin(9600);   //Debug
  pinMode(okLedPin, OUTPUT);
  pinMode(workingLedPin, OUTPUT);
  pinMode(buttonPin, INPUT);
  servo.attach(servoPin);  
  servo.write(startPos);
  pos = startPos;
  findBestPosition();
}

void loop() {

  //Read the photoresistors
  lightVal1 = analogRead(photoRes1);
  lightVal2 = analogRead(photoRes2);
  int diff = lightVal1 - lightVal2;


  //Decide if it should move or not
  if (diff < -tolerance && pos < maxpos) {
    digitalWrite(workingLedPin, HIGH);
    digitalWrite(okLedPin, LOW);
    pos = pos+stepSize;
    servo.write(pos);
  } else if (diff > tolerance && pos > minpos) {
    digitalWrite(workingLedPin, HIGH);
    digitalWrite(okLedPin, LOW);
    pos = pos-stepSize;
    servo.write(pos);
  } else {
    digitalWrite(okLedPin, HIGH);
    digitalWrite(workingLedPin, LOW);
  }
  
  waitWhileButtonCheck(5);
}

//Waits for x seconds and checks for a button press
void waitWhileButtonCheck(int x) {
  int count = 0;
  while(count < x) {
    if(digitalRead(buttonPin) == HIGH) {
      findBestPosition();
      return;
    }
    count++;
    delay(100);
  }
}

//The motor goes from its min position to its max and checks for the position with the most light
void findBestPosition() {
  int ledCycle = 0;
  int bestPos = startPos;
  int bestLight = 0;

  digitalWrite(okLedPin, LOW);
  
  pos = startPos;
  servo.write(pos);
  delay(500);
  
  //Move around and compare the amount of light 
  while(pos < maxpos) {
    lightVal1 = analogRead(photoRes1);
    lightVal2 = analogRead(photoRes2);
    int totalLight = lightVal1 + lightVal2;
    
    if(totalLight > bestLight) {
      bestLight = totalLight;
      bestPos = pos;  
    }

    pos += stepSize;
    servo.write(pos);
    
    //LED blink
    delay(250);
    digitalWrite(workingLedPin, HIGH);
    delay(250);
    digitalWrite(workingLedPin, LOW);
  }
  
  pos = bestPos;
  servo.write(pos);
  delay(3000);
}

Konklusion

Ved brug af photoresistorerer og en servomotor har vi formået at bygge en robot der drejer sig efter solen for at få det mest optimale lysindfald. Ved påsættelse af 2 LED’er har vi samtidig formået at få robotten til at vise hvilken stadie den er i, og om alting virker. Samlet set vurderer vi at problemformuleringen er løst. Dertil er der tilføjet en knap der lader robotten søge efter den bedste position.

Robottens nuværende konstruktion er begrænset i det omfang at det ikke er en dual axis arm, og at der kun er mulighed for at dreje 180 grader. En mulig forbedring af systemet ville være at implementere en ekstra motor, der giver robotten mulighed for at justere vinklen til solen så det bedst mulige lysindfald altid findes. Det opløser samtidig problemet med at den kun kan dreje 180 grader, og robotten kan så få det bedste lysindfald året rundt.
Andre forbedringer ville være at justere hvor ofte robotten søger når det bliver for mørkt. Dette medfører at robotten ikke arbejder så længe at solen ikke er oppe.

Video 2 – The robot tested with a flashlight
More

SolarMaster 5000

SolarMaster 5000

Lavet af:
Frederik Bøttger-Roth – frboe17@student.sdu.dk
Marcus Lomstein Jensen – marcj18@student.sdu.dk

I denne portfølge opgave har vi fået til opgave at lave en solar tracker. Dette indebære en plade vinklet imod solen som kan rotere horisontalt med solen. Dette vil så betyde at den kan følge solens retning når den bevæger sig over himmelen. Vi har valgt at kalde denne konstruktion for SolarMaster 5000.

Overvejelser

De første tanker ved opbygningen var at der på en eller anden måde skulle være en motor der skulle dreje en plade, som repræsentere solcelle panelet, så panelet vender mod solen. 

Robotten består af en servo der håndtere bevægelsen af panelet, samt to LDR-modstande placeret i venstre og højre side af panelet. Når den venstre LDR-modstand får mindre sol end den højre LDR, rotere panelet sig imod højre. Dette må nemlig så indebære at solen er stærkere på højre siden af panelet, hvilket så igen medføre at solen er på højre side. 

Selve opbygningen er lavet i Lego. Dette var bestemt fra starten af da Lego er yderst nemt at prototype i og koblingen af vores motor til de forskellige tandhjul og aksler var relativt nemt i forhold til at bygge konstruktionen af pap. Derudover kunne motoren også nemt påsættes konstruktionen ide jeg vinklede rotationen 90 grader. Servoen kunne således places liggende og nemt sættes fast. 

Valg af motor

Motoren der styre sol trackeren blev valgt til at være en servo. Ikke nok med at der er et let tilgængeligt bibliotek til Arduinos der kan sætte en op, men det var også ligetil at montere servoen til et Lego tandhjul som beskrevet ovenover.  De medførte plastic forbindelser passede perfekt. 

LDR-modstand

Uden to LDR-modstande ville vores solar tracker ikke kunne tracke solen. En LDR-modstand reagere på lys og af den grund giver mere eller mindre modstand til kredsløbet afhængig af lysstyrke. Jo mere lys der kommer, kommer der mindre modstand. 

For at kunne finjustere det information vores arduino modtager fra har vi lavet en spændings fordeler i kredsløbet og fandt ud af at 5000 ohm passede godt til vores opbygning

Problemer under opbygning

Opbygningen af SolarMaster5000 har været henholdsvis problemfrit. Anvendelsen af lego gjorde det nemt at sætte en hurtigt prototype op og teste forskellige setups hen ad vejen. Det eneste problem var om afskærmning var nødvendigt i vores opbygning da vi har vores LDR-modstande langt væk fra hinanden. 

SolarMaster5000 virkede upåklageligt uden afskærmning med en lommelygte, men der kom problemer når den skulle reagere på solen. Vi fandt ud at uden afskærmning, ville den ikke reagere på små lysændringer, så det blev konkluderet at en afskærmning var nødvendigt til det færdige produkt. 

Hardware

Herunder kan i se en diagram tegning over systemet, hvor test LED dioder er fjernet for letlæselighed. 

Herunder kan i se et billede af det færdige projekt.

Opførsel og Software

Herunder har vi et flowchart over SolarMaster5000’s under normal drift. 

Implementering i kode

Koden fungere således at vi har vores setup() – og loop()-metode. Vores setup() sætter vores output og input pins op som der er blevet defined før i koden. 

Nede i loop()-metoden håndtere den kernen af opførelsen. Vi checker om den absolute værdi af den højre og venstre LDR værdi trukket fra hinanden er større end vores threshold. Hvis det er sandt så ville det således betyde at en af LDR-modstandene har en højere værdi end den anden. Hvilken LDR-modstand det drejer sig om bliver så tjekket og afhængig af hvilken LDR-modstand det er, rotere panelet sig enten med eller mod uret. 

Herunder har vi en graf over servo rotations graden og LDR values over 2 timer

Der er nogle hop i grafen i løbet af processen. Test miljøet var ikke optimalt så justering af solar trackeren var nødvendigt i løbet af testing perioden. Nedturen til sidst repræsentere solar trackeren der går tilbage til start positionen da solen ikke længere skinnede ind på solcellen. 

Overordnet kan man do se at over tid så stiger servoens rotation, hvilket betyder at den bevæger sig i mod solen.

Konklusion

Vi har løst opgaven som beskrevet. Vi har fået opbygget en solar tracker der følger solen og rotere tilbage til startposition når lyskilden forsvinder.

Hvis der skulle laves nogle forbedringer så ville det være at tilføje en rotation på x-aksen så selve panelet også kan justere sig efter solens retning. Dette ville så ikke kræve to ekstra LDR-modstande.

Video Demo

More

Solar Tracker v42

Lavet af Jakob Schledermann Winkel og Marcus Møller Pedersen

Design

Figur 1: Billed af robotten og hvordan delene er sammensat. For at se billedet i højre opløsning, så kan det ses på linket:  https://drive.google.com/file/d/1L3P3XDYgBD3Vf–SJ7THQZuNqMKG-lnJ/view?usp=sharing 

systemet er opbygget af en arduino der kontrollere elektronikken. Herfra styre arduinoen en servo motor der kan dreje 180 grader. Servomotoren er placeret på en 3D printet flade der holder motoren fast således den ikke drejer om sig selv. oven på motoren er placeret en arm der har til formål at holde fladen hvor LDR modstanderne er placeret. LDR modstanderne er afskærmet fra hinanden således at der kan skelnes mellem lysindfaldet på den individuelle LDR. Der bliver brugt en breadboard til at sammensætte elektronikken og ledningerne således at der opbygges et kredsløb. Yderliger er der placecret to led’er til at vise hvilken vej robotten drejer mod. til sidst er der placeret modstande på bred boardet, således at komponenterne ikke får mere spænding end de skal have.

Ideén bag designet er at robotten skal dreje rundt omkring z-aksen for at følge med solen, derfor bliver der anvendt en servo motor. Gearinger er håndteret med den servo motor der var i starter sætte, og der er ikke yderliger æmdringer. Motoren er blevet placeret i bunden af designet og er indkapslet i vores base. Dette er gjort for at give robotten højere stabilitet, siden servo motoren er det tungeste punkt i vores robot. Vi har anvendt to photoresistorere for at opfange hvor lyset kommer fra. For at differentiere hvorfra lyset kommer fra har vi sat en plade mellem de to resistorere. På figur 1, er der tegnet hvor sensorerne er placeret. Sensorerne er placeret på en flade, hvor der er en afskærmning mellem dem sålede at det er muligt at differentiere mellem lysindfaldet fra fra de to sider. yderliger er fladen med sensortene placeret på en hævet arm sådan at den nemmere kan opfange lys uden forstyrrelse fra det resterende hardware. 

Problemer Under Design

Vi har ikke skulle ændre på det færdige design, men der blev diskuteret hvor og hvordan vi ville anvende vores to LDR sensorere. I starten var det ikke helt klart hvor mange LDR sensorer vi ville anvende, så der er flere designs som har op til fire LDR sensorer, hvorfra vi kom til den konklusion at der behøvede ikke at være mere end to sensorer, da det endelige design har til formål at dreje om en akse. 

Sammensætning af Hardware

Figur 2. Diagram over hvordan hardwaren er sammensat. Højere opløsning kan findes på linkethttps://drive.google.com/file/d/1TjoodBUS59i2rFjr3hbTGmPSq2l71O0u/view  

Designet er blevet opbygget i tinkercad, hvorfra en fungerende prototype blev lavet. Dette medførte at der var mindre problemer i at tilpasse til de rigtige lysniveauer for rigtige omgivelser. Dette er blandt andet grunden til at vi introduceret en tolerance variabel i systemet, sådan at systemet kunne tilpasses til virkelige omgivelser, hvorfra robotten følger solen. Yderliger er resistorende  der er forbundet til LDR sensorerne bliver udskiftet et par gange for at se hvilke der kunne give den bedste præstation. Ud over dette har hardwaren virket upåklageligt uden problemer. 

Robotten følger en række tilstande der bliver bestemt af de  pågældende lysindfald. Altså læser robotten lysindfaldet på de to LDR sensorer, herefter bestemmes det hvilken af de to sensorer der har det største lysindfald, hvorfra fra robotten vil dreje sig mod retningen der har større lysindfald. dette vil fortsætte indtil de to sensorer bliver udlignet i lysindfald med en bestemt tolerance. Hvis lysindfaldet falder under en bestemt værdi så ville robotten dreje sensor fladen mod minimumspunktet for servoen. Dette ville efterligne virkeligheden når solen går ned efter en lang dag, så kan robotten nulstille sig selv for at følge solen den næste dag. 

Figur 3. Flow diagram der viser robottens opførsel.

Kodning af Robotten

Figur 4: Første kodeblok. Variabel deklarationer. 
Figur 5: Anden kode blok, viser loopet som der køres igennem.

Vores variabler:

  • leftLDR and rightLDR repræsenterer venstre og højre photoresistor. Værdierne er mellem 0 og 1023, det kommer an på hvor meget lys der rammer dem. Hvis den ene har en højere værdi end den anden, så drejer robotten sig i den retning.
  • servolimitLow og servoLimitHigh repræsenterer maks og minimum vinklerne servo motoren kan dreje. dvs at minimum viklen er sat til 5 grader og maks vinklen er 175 grader.
  • Vi har inkluderet et tolerance variabel hvis mål er at være en buffer eller tolerance i forhold til forskellen mellem leftLDR og rightLDR værdierne. Grunden til at det er vigtigt er så robotten ikke hele tiden drejer sig ved den mindste forskel.
  • Når robotten ikke bevæger sig, så er state sat til 1, og hvis den ikke bevæger sig bliver den sat til 0. Mens state er 1 så bliver dataen logget.
  • start og count variablerne er begge brugt til at holde styr på tid så vi kan logge tid med dataen.

Der har ikke været de store problemer med at få koden til at virke, andet en lidt tilpasninger i form af hvordan man deklarere hardware og pins til at udføre specifikke handlinger. 

Grafer

Grafen viser lysindfaldet på LDR sensorerne og tilsvarende servo position på det pågældende tidspunkt. Dataen i grafen er samlet over en periode på seks timer. Yderliger bliver data tilføjet når servo motoren bevæger sig således at alle ændringer gemmes. På den pågældende dag var det stærkt overskyet så det er meget begrænset ændringer i servo position. 

Figur 6. Graf over solindfald og servo motor position, over 6 timer. (Det var overskyet). Højere opløsning se linket: https://drive.google.com/file/d/1ableKxBQH6QkbCK8BsC7ceTKYrSZKQgh/view?usp=sharing  

Konklusion

Robotten opfylder de krav der er stillet og fungere efter hensigt. robotten er i stand til at følge solen, og andre lyskilder, og den kan også nulstille sig selv til en ny dag med sol. Der er dog stadigvæk punkter hvor den kunne forbedres. Når der ikke er noget lysindfald så nulstiller robotten sig til en angivet position. Dette kunne forbedres sådan at den ikke er sat til et statisk punkt. Den kunne med fordel derfor søge efter en lyskilde, eller solen for forbedret præstation. Yderliger kunne tolerances nok sættes bedre givet tilstrækelig testkørsel. 

Video

Video demo kan findes på linket herunder. 

https://drive.google.com/file/d/1G4sFeHOfDe3HDnQA4MbBmUtTqbSnZ7ax/view

More

Søren Solsystem

Gruppe:
Thomas Steenfeldt Laursen & Morten Krogh Jensen

Opbygning af Solar Trackeren

Til det overordnede design har vi taget to papkasser, hvoraf den ene fungerer som base for robotten og holder for motoren. Ovenover har vi et stykke bukket pap monteret til motoren hvor de to Photo resistorer (LDR) sidder med en skillevæg til at kaste skygge på dem efterhånden som solen bevæger sig over himlen.

Dette design tillader at robotten kan bevæge den ene plade uafhængigt af basen, og dermed med minimal friktion rette vores LDR’er mod solen.

De 2 LDR’er er forbundet til breadboardet hvor vi med modstande har lavet en spændingsdeler, som giver os den værdi vi bruger som input til vores Arduino. Selve stepper motoren er forbundet til et stepper motor driver modul, som derefter er forbundet til strømmen som vi alligevel har på breadboardet, og til 4 digitale porte på Arduinoen, hvorfra motoren får sine instruktioner. Sidst men ikke mindst så har vi på breadboardet placeret 3 status LED i henholdsvis hvid, grøn og rød, hvor Rød lyser ved rotation mod venstre, og Grøn lyser ved rotation mod højre, og hvid lyser ved ingen rotation, som et symbol på at den er placeringen er blevet udregnet til at være optimal for den nuværende mængde sollys. Hver LED er udstyret med hver sin 330 ohms modstand, for at sikre at LED’erne ikke springer.

Teknisk sammensætning af hardware

Herunder ses et kredsløbsdiagram over hele konstruktionen.

Spændingsdelere

En photo-resistor er en modstand hvis størrelse afhænger af mængden af lys den udsættes for. I tilfældet med disse LDR-modstande, så sænkes modstanden når belysningen øges. I vores projekt udnytter vi denne egenskab til at justere solpanelernes retning i forhold til hvilken modstand der bliver udsat for mest lys.

På kredsløbsdiagrammet kan man se de to LDR-modstande sat sammen i hver sin spændingsdeler-kredsløb. Hver LDR-modstand er serieforbundet med en almindelig modstand på 10k ohm. Spændingen imellem LDR-modstanden og den almindelige modstand vil variere når LDR-modstanden udsættes for forskellige mængder lys. Denne spænding måles ved at forbinde den en af til Arduinoens analoge porte (A0 og A1), som det kan ses på kredsløbsdiagrammet. Hvis man kender størrelsen for de to modstande, kan man finde spændingen imellem dem ved hjælp af følgende formel:

Det Arduinoen måler er V_out, og ud fra denne kan det bestemmes om LDR-modstanden udsættes for meget eller lidt lys. Arduinoen har en 10-bit A/D-converter og vil derfor returnere et heltal mellem 0 og 1023, hvor 0 svarer til 0V og 1023 svarer til 5V. For et heltal n, vil spændingen svare til følgende udregning:

Det var ikke ligegyldigt hvilken størrelse fast modstand vi valgte at bruge til spændingsdelerne (R1 og R2). Man ønsker at vælge modstande som giver stor variation i V_out siden det giver en højere ”opløsning”, og man kan registrere finere ændringer i lysstyrken. Vi oplevede at en fast modstand på 10k ohm gav mulighed for meget stor variation (ca. fra 30 til 900 på Arduinoens A/D-converter.

Stepper Motor

Til at drive rotationen på vores robot valgte vi at bruge en stepper motor da den tilbød en nem mulighed for at styre hastigheden og antallet af steps. Dette bruger vi blandt andet til at sætte robotten tilbage til udgangsposition lige så snart at solen går ned, denne del er videre beskrevet i kodeafsnittet.

Stepper motoren er en 4 faset 5vdc motor[1], og fungerer ved at vi via vores stepper motor driver modul kan aktivere hver enkelt spole indeni, sådan at den rotor der sidder inden i som har en række tænder, drejer over og står på linje men de aktiverede statore.

Statore er de grupper af spoler som findes inden i stepper motoren og er den ikke bevægende del, og det er disse spoler som kan aktiveres for at skabe rotation i rotoren. Rotoren er den bevægende del som flytter sig hen til det næste set tænder, og dermed har motoren nu taget et skridt.

I datasheet for vores stepper motor kan vi læse os frem til at motoren skal bruge 64 skridt af 5,625 grader/skridt til at nå en hel rotation, derudover kan vi se at gearingen i motoren er en 64:1, så for at udregne det total antal steps motoren tager, så skal vi altså gange de 64 skridt på en omgang, med de 64 fra vores 64 til 1 gearing:

64 * 64 = 4096

Da vi i vores programmering tager 8 steps ad gangen grundet den sekvens vi aktiverer spolerne i, så skal vi dividere med 8 for at få det totale antal steps vi skal bruge i koden på en rotation.

4096 / 8 = 512

Dette resultat ville man i koden kunne bruge til at udregne antal steps for f.eks. hele, halve og kvarte rotationer, hvis man ønskede sin robot skulle kunne lave dem.

Solsystemets opførsel

Overordnet flowdiagram

Følgende flowdiagram beskriver robottens overordnede opførsel. Kort sagt, så læser den værdierne af de to spændingsdelere og sammenligner dem med hinanden. Den ene værdi er tilstrækkeligt højere end den anden, så vil robotten dreje for at udligne værdierne. Hvis sensorværdierne er ens, foretages der intet. Hvis begge sensorværdier viser lav belysning, vil robotten se det som et tegn på at solen er gået ned, og den vil dreje tilbage til sin startposition (positionen robotten havde da den tændtes). Denne opførsel vil køre i et konstant loop så længe robotten er tændt.

Kode

Herunder ses hele koden til solsystemet. Den første metode der eksekveres er setup(). Her initialiseres alle porte til deres formål. Porte A, B, C, og D (digital port 4, 5, 6, og 7) initialiseres som OUTPUT siden disse skal styre motorens bevægelser. De tre LED-porte sættes også til output.

Herefter begynder loop()-metoden at eksekvere. Den læser de to spændingsdelere med analogRead()-metoden og gør dem klar til sammenligning. Bemærk at variablen margin  initialiseres. Denne fungerer som en buffer og sørger for at solar trackeren ikke reagerer på de små usikkerheder og svingninger på spændingsdelerne. Vi oplevede også at de LDR-modstande ikke reagerede ens på lys. Når udsat for samme lys-mængde, ville den venstre spændingsdeler altid give en højere V_out end den højre. Denne forskel blev mere markant jo mindre lys de blev udsat for. Derfor stiger “margin” i takt med at spændingsdelernes værdier stiger for at modvirke forskellens ændrende markanthed.

Solar trackerens hovedfunktionalitet foregår på linje 114 i koden. Her tjekkes det om forskellen på de to sensorværdier er over margin. Hvis det er tilfældet, vil motoren enten dreje ét step med eller mod uret baseret på hvilken af sensorværdierne der er højest. Arduinoen får motoren til at dreje ved at kalde onestep()-metoden. Som beskrevet tidligere, så foretager denne metode rent faktisk otte steps. Ét enkelt step foretages ved at kalde metoden write() med værdier for hvilke spoler der skal aktiveres. Otte af disse write()-metoder er i onestep() sat sammen i den rigtige sekvens så motoren enten drejer lidt med eller mod uret. Variablen  styrer hvor hurtigt motoren drejer. Efter onestep() er kaldt, ændrer Arduinoen heltallet step_pos med +1 eller -1 afhængig af hvilken retning motoren drejede. step_pos hjælper med at holde styr på motorens position.

If-sætningen på linje 109 tjekker om solen er gået ned. Vi oplevede at Arduinoen læser værdier omkring 800 når LDR-modstandene udsættes for aften-lignende lys. Hvis begge er over denne værdi, kaldes metoden return_to_start(). Denne metode bliver ved med at dreje motoren indtil variablen step_pos er nul og motoren har fundet sin oprindelige startposition.

int A = 4;
int B = 5;
int C = 6;
int D = 7;
int step_pos = 0;

int sensorLeft = A1;
int sensorRight = A0;

int ledRedPin = 11;
int ledGreenPin = 12;
int ledWhitePin = 13;

long t = 0;

void setup() {
  Serial.begin(9600);
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(ledRedPin, OUTPUT);
  pinMode(ledGreenPin, OUTPUT);
  pinMode(ledWhitePin, OUTPUT);
}

void write(int a, int b, int c, int d) {
  digitalWrite(A, a);
  digitalWrite(B, b);
  digitalWrite(C, c);
  digitalWrite(D, d);
}

void onestep(bool clockwise) {
  int d = 15;

  if (clockwise) {
    write(1, 0, 0, 1);
    delay(d);
    write(0, 0, 0, 1);
    delay(d);
    write(0, 0, 1, 1);
    delay(d);
    write(0, 0, 1, 0);
    delay(d);
    write(0, 1, 1, 0);
    delay(d);
    write(0, 1, 0, 0);
    delay(d);
    write(1, 1, 0, 0);
    delay(d);
    write(1, 0, 0, 0);
    delay(d);
  } else {
    write(1, 0, 0, 0);
    delay(d);
    write(1, 1, 0, 0);
    delay(d);
    write(0, 1, 0, 0);
    delay(d);
    write(0, 1, 1, 0);
    delay(d);
    write(0, 0, 1, 0);
    delay(d);
    write(0, 0, 1, 1);
    delay(d);
    write(0, 0, 0, 1);
    delay(d);
    write(1, 0, 0, 1);
    delay(d);
  }
}

void return_to_start() {
  while (step_pos != 0) {
    if (step_pos > 0) {
      onestep(false);
      step_pos--;
    } else {
      onestep(true);
      step_pos++;
    }
  }
}


void loop() {
  digitalWrite(ledRedPin, LOW);
  digitalWrite(ledGreenPin, LOW);
  digitalWrite(ledWhitePin, LOW);

  int leftValue = analogRead(sensorLeft);
  int rightValue = analogRead(sensorRight);
  int margin = 5 + 0.05 * (leftValue + rightValue);

  if (millis() >= t + 1000) {
    t = millis();

    Serial.println();
    Serial.print(leftValue);
    Serial.print("  ");
    Serial.print(rightValue);
    Serial.print("  ");
    Serial.print(step_pos);
    Serial.print("  ");
    Serial.print(margin);
  }

  if (leftValue > 800 && rightValue > 800) {
    return_to_start();
    return;
  }

  if (abs(leftValue - rightValue) > margin) {
    if (leftValue < rightValue) {
      digitalWrite(ledGreenPin, HIGH);
      onestep(true);
      step_pos++;
    }
    else if (rightValue < leftValue) {
      digitalWrite(ledRedPin, HIGH);
      onestep(false);
      step_pos--;
    }
  } else {
    digitalWrite(ledWhitePin, HIGH);
  }
}

Test

Vi testede solsystemet ved at sætte det i vinduet over et par timer. Det var hensigten at robotten skulle følge solen som bevægede sig over himlen. En video af testen kan ses herunder:


Under hele testen opsamlede vores computer data om solar trackerens placering og sensor-værdier. Grafen herunder viser variablen step_pos (blå) og forskellen mellem de to sensorers værdier (orange) som funktion af tiden. Det fremgår af grafen at forskellen mellem de to sensorværdier er rimelig konstant igennem hele testen. Det har altså lykkes af solar trackeren at opnå dette ved at dreje sig (som den blå graf viser).

Konklusion

I projektet skulle der bygges en robot som afhængig af sollys justerede sig til altid at så vinkelret på lyskilden, dette er lykkedes ved hjælp af pap samt de elektroniske komponenter som vi havde tilgængeligt fra vores Elegoo start kit. Robotten vurderer på baggrund af 2 LDR hvor lyskilden er stærkest, og retter sig derefter ind hvis der er behov.

Såfremt at robotten skulle forbedres, ville et mere robust design til at modstå vejr miljøet være at foretrække da den nuværende konstruktion i pap ville miste bæreevne så snart det blev vådt, eller kunne blæse væk hvis der kom vind. Derudover kunne man tilføje endnu en motor som justerede robotten vertikalt, således at robotten ville kunne justere sig opad hvis solen stod højt på himlen. Sammen med den ekstra motor og eventuelt et ekstra sæt LDR kan vi sikre at robotten altid vil kigge direkte imod lyskilden.

[1] https://ardustore.dk/error/Manuel%20-%2028BYJ-48%20Stepper%20Motor.pdf

More

“FLOWER POWER”

Vejledere:
Bente Charlotte Weigelin & Jacob Nielsen

Gruppe:
Eva K. Nøhr Larsen, Jens H. Jakobsen, Nickolai Petersen.

Indledning

Systemet “Flower Power” er en simulering af et solcelleanlæg som er bygget til at simulere en blomst, blomsten, som i virkeligheden følger solens lys for at optage energi. I dette tilfælde har vi benyttet photoresistore som følger en hvilken som helst lyskilde.

Blomsten er monteret på hjørnet af en rummelig kasse der med fordel er blevet brugt til at indeholde systemet bestående af arduinoen.

Systemet er bygget op af to photoresistore på hver sin side af blomstens hoved, mellem kronbladene. Stilken med en 45º graders vinkel er sat på en micro servo, som styres fra arduinoen. Kassen har desuden en RGB-LED-diode som styret af arduinoen angiver hvilket stadie systemet er i, ud fra hvad photo-resistorerene registrere.

Beskrivelse af systemet:

Systemet indeholder:

  • To photoresistore med et ekstra udløb i henholdsvis A0 og A1
    • Pin til arduino ligger mellem fotoresisteren og modstanden.

  •  To forskellige modstande.
    • Værdierne fra de variable photoresistore bør angive ens værdier, hvis ikke kompenseres der for det ved hjælp af forskellige modstande.

  • Micro Servo med digital port (til port 3)
    • Servo har kun et spin på 180º.

  • RGB-LED-diode med ben i port 9-10-11.
    • Samt dertilhørende modstand.

Hvorfor er systemet opbygget som den er for at løse opgaven

Systemet er designet og bygget ud fra ideen om en blomst som går efter sollyset. Det vigtige i opgaven var at photosensorene stod i en fast position til at kunne opfange solen. Dette er grunden til at blomsten har en hældning på 45º, i forhold til solens position. Systemet kan bevæge sig mod højre eller venstre efter hvor der er mest lys, samt finde en nat position på micro servoens 45º mod syd-øst, hvis lysniveauet er tilpas lavt.

Tanker bag opbygningen.

Designet er opbygget efter et simpel princip som skal virke så virkelighedstro til en blomst med dets naturlige mulighed for at følge solen.


Illustration 1 – Jordens Hældning

Billedet ovenfor illustrerer at solens lys falder i en vinkel på 45º  ud for Danmark i forhold til jordens akse som ved jævndøgn er på 90º.


Illustration 2 – Fast Hældning

Billedet ovenfor illustrere hvorfor en fast vinkel på stilken bør være 45º, især omkring projektets afleverings dato der er tættest på forårs-jævndøgn.

B.S. Ingemanns “ I østen stiger solen op” og at det er varmes mod syd er gode husketeknikker, for at komme frem til hvilken vej systemet skal vende.


Illustration 3 – Systemets placering

Systemet skal vende ved en 90º graders position stik syd for optimal funktion. Herefter vil den røde lampe lyse når systemet bevæger sig mod øst og bevægelse mod vest vil indikeres af den grønne lampe.

Billede gennemgang af Tinkercad modeller i de forskellige stadier:

Herunder: Blåt lys fra RGB-LED-diode – Genstart af systemet, når begge photo resistorer registrere et niveau under værdien 300 antager vi at der er mørkt og servomotoren flyttes tilbage til nat position mod syd-øst, der er på de 45º grader, mellem syd og øst.


Illustration 4 – Start Position

Herunder: Rødt lys fra RGB-LED-diode: Systemet registrere mere lys fra venstre photo resistor og servomotor drejer mod venstre/øst.


Illustration 5 – Venstre Drej

Herunder: Grøn lys fra RGB-LED-diode: Systemet registrere mere lys fra højre photo resistor og servomotor drejer mod højre/vest.


Illustration 6 – Højre Drej

Arduinoen fungerer som systemets CPU. Værdierne som photo-resistorerne sender til arduinoen, bliver brugt som central værdier, de bestemmer hvordan de forskellige enheder skal reagere. Værdierne bliver sat i en venstre-værdi og i en højre-værdi, som bliver sat op mod hinanden.

Hvordan er gearingen og hvorfor?

Vi har anvendt servomotor, hvor det kun er muligt at opererer mellem 0 og 180 grader. Gearingen er inde den blå kasse i forlængelse af  motoren. Motoren kan bevæge sig begge veje ved hjælp af pulse signaler fra arduinoen sendt fra koden, i stedet for at ændre strømretningen.

Hvor er motoren placeret og hvorfor?

Motoren er placeret på undersiden af æskens låg, med et hul så stilken kan sidde på den roterende del af servomotoren.

Motorens roterende del stikker op fra kassens top og er placeret i hjørnet, så motorens kasse på undersiden ikke kommer i karambolage med arduino eller breadboard når kassen lukkes.

Hvordan er h-broen opbygget inkl begrundelser og beregninger?

Vi har i dette projekt ikke brugt H-broen, men en micro servo der kan ændre retning ud fra signaler i kodningen over arduinoen og pulse-output -og ikke ved at ændre strømretningen over H-broen til motoren.

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

Da vi kun bruger 5V udgangen på arduinoen og bruger derfor kun arduinoens indbyggede spændingsregulator, har vi ikke skrevet mere i dette afsnit, da vi også bruger en micro servo, som skal bruge de 5V.

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

Vi har benyttet to photoresistore, sensorerne er begge placeret på hver side af blomstens hoved, sådan at blomstens hoved altid vil være hvor der er mest direkte lys. De øjne der er placeret på blomstens hoved, sørger for at lysindfald fra en vinklet retning ikke vil lyse på begge fotoresistore samtidig og derved vil systemet bevæge sig mod lyset.

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

Da selve ideen til systemet var klarlagt var det derudfra nemt at designe udseendet, hvor enigheden var at systemet skulle ligne en blomst.

De to photo-resistorer viste i starten forskellige værdier trods samme modstand, men efter erkendelsen af at de to photo-resistorer kunne være variable, løste det sig at sætte forskellige modstande på hver af photo-resistorer, så de gav nogenlunde ens værdier.

Ydermere var der en meget kort overgang påtænkt at photo-resistorerne skulle sidde på kassens overside, men det passer ikke med hvordan koden er opbygget, da kassen ikke flytter sig efter lyset.

Hvordan robottens hardware er sammensat.

En diagramtegning:


Illustration 7 – Diagram Tegning

Billeder og beskrivelser på de enkelte delkomponenter


Illustration  8 -Systemets delkomponenter


Illustration 9 -Arduino: Arduinoen er udstyret med den microcontroller som vi har fortalt via kode, hvordan den skal reagerer med andre komponenter.


Illustration 10 -Photoresistor: Photoresistorer er en variabel resistor som ændre sin modstand baseret på mængden af lys som rammer den.

Illustration 11 – Micro Servo Motor: Dette er en gearet motor som kun kan roterer 180 grader. Den kontrolleres ved at sende elektriske impulser fra arduinoen som fortæller til hvilken position servomotoren skal flytte sig til.

Illustration 12 & 13 – RGB-LED: Kaldet Red-Green-Blue-Light Emitting Diode, er en halvleder diode som udsender et lys grundet den energiudladning der sker når fotoner springer fra anoden til kathodens reflekterende hul.

Det særlige ved denne diode er at alt efter hvilket ben arduinoen bruger, vil de bruge hver deres bølgelængde og dermed kan man frembringe stort set alle farver ved at skrue på intensiteten af de tre farver rød, grøn og blå, ved additiv farveblanding.

Illustration 14 – Modstande: Modstande modstår den strøm af elektrisk energi der gennemløber i et kredsløb. Modstande eller resistorerers værdi måles i ohm og de farvede bånd indikerer værdien på modstanden.

Illustration 15 – Mini Breadboard: Dette er et panel hvor nogle af de forskellige huller er forbundet. Her er det 1X5, altså de første 5 huller på første række og så fremdeles. Det gør at man hurtigt kan lave opstillinger til test og prototyper, uden at skulle lodde eller lave printplader.

Har der været nogle problemer ift. at få hardwaren til at virke?

Ja, der har været problemer. Problemet lå hovedsageligt i at vores fotoresistore ikke opfangede og dermed afgav de samme værdier. Dette betød at sensoren på vores højre side, havde en højere værdi på trods af at solen stod lige på systemet. Dette gjorde at systemet altid kiggede mere mod højre end venstre.
Løsningen blev at vores resistor på den venstre foto-resistor havde en 4,7k Ohm resistor i stedet for 10k Ohm. Dette var nok til at værdierne fra de to sensorer lå nogenlunde ens, når solen stod lige på robotten.

Ved de individuelle opbygninger af systemet har det ligeledes været nødvendigt først at sikre sig ens værdier fra fotoresistorene, ved hjælp af forskellige modstande.

Derudover har der været mindre fejl som at “stilken” på systemets blomst er faldet af servoens gearing, at batteriet er løbet tør eller at en ledning ryger ud af breadboardet hvis man åbner kassen for højt.

Hvordan er robottens opførsel implementeret.

Hvad er de overordnede opførsel/metoder for robotten?

Efter arduinoen er blevet tændt modtager den input fra de to sensorere. Koden sørger for at de to input sammenlignes og vurderes om, value et eller value to er højest -eller om de begge er under en fast værdi. Ud fra den sammenligning sender arduinoen impuls til servoen om at forøge eller formindske servoens værdier, alt efter hvilken fotoresistor værdi der er højest. 

Hvis værdi-1 er højst drejer serveren til venstre og omvendt i tilfælde hvis værdi-2 er højest. I tilfælde af begge sensorer registrerer en value under 300 sættes systemet til morgen position på 45º grader mod syd-øst, som er servoens værdi på 135.

Drejer systemet til venstre bliver der sendt et signal til RGB lampen om kun at bruge rødt lys, drejer den til højre, bruges kun grønt lys og ved morgen-position bliver bruges rent blåt lys.

Et flow-diagram, som beskriver robottens opførsel:


Illustration 16 -Flow Diagram

Inkluder kode + beskrivelse.

#include <Servo.h>
Servo myservo;

int pos = 0;
int redPin = 9;            // RGB-rødt ben i port 9.
int greenPin = 10;         // RGB-grønt ben i port 10.
int bluePin = 11;          // RGB-blåt ben i port 11.

int servoVar = 90;   int delta = 10;            // Forskel på 10 for at reducerer at systemet opdaterer position.

void setup() {
  myservo.attach(3);             // Micro Servo i port 3.
  Serial.begin(9600);            // Hvor hurtigt data sendes.

  pinMode(redPin,OUTPUT);        // Konfigurerer en specifik pin til at
  pinMode(greenPin,OUTPUT);      // være output.
  pinMode(bluePin,OUTPUT);      
}

void loop() {

  myservo.write(servoVar);

  int analogValue1 = analogRead(A0);  // Lysværdier i int, læses
  int analogValue2 = analogRead(A2);  // henholdsvis fra port A0 og A2.
  Serial.print(analogValue1);     // Værdier fra photoresistor 1 printes
  Serial.print(‘/’);              // i Serial Monitor.
  Serial.print(analogValue2);     // Værdi fra photoresistor 2.   Serial.print(‘/’);              // Separator.
  Serial.println(servoVar);       // Servo motorens værdi udskrives.
  delay(1200);


  if (analogValue1 >= analogValue2){// Hvis blomst skal dreje til højre.
    servoVar++;                     // Forøger servoens værdi.
    RGBcolor(0,255,0);              // Tænder RGB diode med grønt lys.
  }
  else if (analogValue1 <= analogValue2){// Hvis blomst skal dreje til          venstre.
    servoVar–;                     // Formindsker servoens værdi.
    RGBcolor(255,0,0);              // Tænder RGB diode med rødt lys.
  }
 
  if (analogValue1 <= 400 && analogValue2 <= 200){ // Ved manglende lys, sættes blomst til morgen-position.
    servoVar = 135;                  // Sætter servoen til værdien 135.
    RGBcolor(0,0,255);               // Tænder RGB diode med blåt lys.
  }
  if (servoVar > 180){ // Sikre servoVar’s værdier er mellem 0-180.
    servoVar = 180;
  } else if (servoVar < 0) {
    servoVar = 0;
  }
}
void RGBcolor(int redLight, int greenLight, int blueLight) // RGB farver opsættes.
{
  analogWrite(redPin, redLight);
  analogWrite(greenPin, greenLight);
  analogWrite(bluePin, blueLight);
}
 

Grafer for testkørsel med rigtig sol:

Forklaring af graf.

Grøn og rød linje er værdierne fra henholdsvis højre og venstre photoresister, farverne indikerer samtidig hvilken vej blomsten vil dreje alt efter hvilken værdi der er højest.

Blå linje er servoens værdier som stiger når den grønne linje har højeste værdier og falder når den røde linje har den højeste værdi.
Se bilag for resultater.

Funktionen med grafen

Grafen viser hvordan værdierne fra photoresisterne, har indflydelse på hvilken retning servomotoren drejer. Designet af systemet gør at den retning servoen drejer, får blomsterhovedet og derved photoresisterne til at vende mod solen.

Beskrivelse af forløb

Starten af grafen viser hvordan vores “hviletilstand” fungere. Værdierne på den røde og grønne photoresisterne er ikke til tilstrækkelig nok til at systemet gør noget, og derfor vil servoen stå ved 135 grader. (11:29:27 => 11:29:50).
Som lyset bliver stærkere, og værdierne på rød og grøn stiger, kan systemet skelne mellem de 2 værdier, ved at måle hvilken værdi er størst. I det første tilfælde er det er den grønne værdi højere end den røde, antaget at solen står op i øst. Derfor siger værdien i grader. Dette er dog kun til 180, da servoens maks værdi er 180. (11:29:51 => 11:30:23)
Senere sker der et skift i solens retning, og systemet opfanger dette ved at den røde værdi er højere end den grønne. Værdien i grader falder i dette tilfælde. Dette er dog kun til 0 grader er opnået, da servoen ikke kan dreje længere end dette. (11:30:24 => “The End”)

Servoens værdier i stik øst er 180 og i vest 0, derfor vil servoens værdi falde dagen igennem når blomsten bevæger sig fra øst til vest -og forventet stige i det tidsrum fra nat-venteposition til lyset er stærkt nok til at blomsten igen kan registrere lyset.

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

Når man skal programmere til en robot, og denne robot skal bevæge sige ved hjælp at nogle specifikke enheder, er det ofte være udfordringer i robottens programmering.

En af udfordringerne var at koden sendte uendelige værdier og ikke var begrænset til de 180 grader som servoen kunne bevæge sig. Der gik alt for lang tid før servoen drejede modsat retning, efter at være nået ud i yderposition. Efter at se koden igennem et par gange gik det op for os at værdierne kunne være større eller mindre end 0-180 og fik derfor indsat følgende for at indsnævre værdierne.

if (servoVar > 180){

    servoVar = 180;

  } else if (servoVar < 0) {

    servoVar = 0;

Dette skabte dog et andet problem. Når solen står op igen skulle robotten bevæge sig fra 0 til 180º grader (vest til øst), som godt kunne tage tid og spilde tiden med sollys. Dette blev løs ved at lave en vent-på-morgensol-tilstand, som aktiveres når begge  photo resistorer input var tilstrækkelige lave. Dette ville starte en nattilstand, som sætter servoen tilbage på 45º grader eller stik syd-øst. Vi havde i starten sat denne position til 90º grader eller stik syd, men efter en dialog i gruppen, ændrede vi det til de 45º grader eller syd øst, da den østvendte photo resistor derved ville have nemmere ved at registrere morgenlyset en fra en 90 graders syd position.

Konklusion

Vi fik til opgave at konstruere en solcelle styring. Ud fra denne problemformulering byggede vi robotten “Flower Power”. Vi byggede konstruktionen ud fra to photoresistore som opfanger lys, samt en servo som drejer konstruktionen i den retning, hvor lyset kommer fra. Servoen er styret af en Arduino, som modtager input fra de to photoresistore.

Med arduinoens kode formåede vi også at få systemet til at følge solen med et delay, som gør at systemet ikke opdateres hvert millisekund. (se video 1)

Dertil er også en deltaværdi som der skal mere end 10 værdier i forskel mellem de to fotoresistore værdier før servoen skal dreje -og derved undgås det at systemet står og kompenserere positionen frem og tilbage.

Grundet vejrets omtændigheder har det været svært at lave en test i naturlige omgivelser, men heldigvis fandt vi en solopgang og solnedgang i solrigt vejr, samt lidt en tåget aften under en paraply.

Løser robotten opgaven ift. opgaveformuleringen?

Opgaveformuleringen lød på at konstruerer en solcelle styring og da systemet er opbygget til at reagerer efter fotorestistorenes højeste værdi og styre blomsterhovedet derefter, må dette krav være opfyldt.

Systemet bruger kun en servo motor og stilkens knæk er vinklet til de 45º grader så blomsterhovedet er således vinklet.

Når lysindfaldet er lavt over begge photoresisterne vil systemet sætte værdien på servomotoren sådan at blomsten drejer til en position mod syd-øst, så systemet kan opfange morgenens første solstråler.

Overvejelserne omkring valg af motor faldt på servomotor, da vi blandt andet ikke fandt det nødvendigt at skulle bruge en bredere vinkel end de 180º grader som servo motorens bevægelse er begrænset til.

Af enkeltheds hensyn er kun tilføjet en RGB-diode for lysindikation, dog kun med en modstand mellem diode og ground, da vi kun bruger de tre rene farver rød, grøn og blå.

Systemet er desuden testet og video dokumenteret i naturlige omgivelser samt en kort simulering hvor data er registreret og vist via en graf.

Det kan således konstateres at ud fra løsningen af ovenstående krav, løser robotten opgaverne fra opgaveformuleringen.

På hvilke punkter kan systemet forbedres? -og evt. hvordan?

En forbedring af systemet kunne være introduktionen til en solcelle. Dette ville gøre at at systemet ikke mister strøm så hurtigt og måske endda generere strøm til at flytte motoren.

En anden tilføjelse, ville være implementering en ekstra motor i knækket af blomsten. Denne implementering til et toakset system, ville kunne gøre at blomsten kunne ændre vinklen op og ned, så blomsterhovedet kunne vende mere vinkelret mod solen, trods fx et ujævnt underlag.

Derudover kunne der gennemtænkes mere energibesparelse, lave lysindikatoren mindre synlig ved at bruge højere modstande.

Eller sætte antallet af registreringer yderligere ned eller deltaværdien mellem de to photoresisterne værdier yderligere op, så der skal højere forskel til før systemet skal dreje.

Man kan også bruge en form for sleep-mode, som enten lukker dele af systemet ned i en given periode eller lukker hele systemet. Her skal der downloades et library og man kan derefter bruge Idle Sleep Mode og derigennem sætte hvor lang tid arduinoen skal bruge low power og hvornår den igen skal tændes på almindelig styrke.

Video

Første “time lapse” video er optaget med formål at vise systemets reaktion ved solnedgang. Under optagelsen sætter batteriet ud og bliver skiftet, vejret er meget gråt og regnfuldt, så blomsten bevæger sig meget tilfældigt, men kameraet løber tør for strøm inden det er helt mørkt.

Anden time lapse video viser at solen registreres korrekt, dog går stilken løs under optagelsen og derfor bevæger blomsten sig ikke.

Tredje time lapse video viser en fin solnedgang med skyggerne vandre over græsset, sidst på aftenen fanges refleksioner fra nærliggende huse og sidst flytter systemet sig til morgen-position -og derefter kan man se ved den manglende lysstyrke på RGB-dioden at batteriet igen er ved at løbe tør for strøm.

Demo-video.

More

Solar Tracker Mak1

•Navn på robotsystemet

    “Solar tracker MAK1”

•Navne på gruppemedlemmerne

Anders Gaarsdal

Kasper Wogelius

Michelle Larsen

•Hvordan ser systemet ud? –husk billede

•Hvorfor er systemet/robotten opbygget som den er ift. at løse opgaven.

oHvilke tanker ligger bag ved opbygningen

        Sensorerne er sat på hver sin side af solcellepanelet, så de drejer med opbygningen efter solens position. Derudover er det hele vinklet 45 grader for at sikre det bedste lysindfald. På den måde sikres, at sensorerne og solcellen altid modtager det optimale lys input.

De ikke lyskrævende dele af opstillingen er gemt i en boks under solcellen, så disse ikke fejlagtigt skygger for lysindfaldet og giver motoren så fri bevægelighed som muligt.

oHvordan er gearingen og hvorfor?

        Der bliver ikke brugt en gearing i systemet da der bliver brugt en servo motor og ikke en DC motor.

oHvor er motoren placeret og hvorfor dér

Motoren er placeret i bunden af solcelle-konstruktionen sådan at der kan drejes med hele panelet med mindst muligt energi input.

oHvordan er h-broen opbygget inkl begrundelser og beregninger?

        Da vi benytter servo motor, er der ikke en h-bro

oHvordan er spændingsregulator kredsløbet opbygget inkl begrundelser og beregninger?

        Da der er brugt en servo motor har vi ikke brugt spændingsregulatorer i kredsløbet ud over de indbyggede i arduinoen.

oHvilke sensorer er benyttet og hvor er de fysisk placeret på robotten

        Der er anvendt to lyssensorer, der er placeret på hver side af solcellen til måling af lysinput.

Med denne placering måles der på, hvilken sensor, der modtager det største input, hvilket bestemmer, hvilken retning solcellen bevæges.

oHar det været problemfrit at opbygge robotten eller har den ændretform/sensor-placeringer flere gange?

        Den største udfordring ved opbygning af robotten har været forskellen på følsomheden i lyssensorerne.

Robotten har dog ikke ændret form i løbet af projektet.

•Hvordan er robottens hardware sammensat?

oLav en diagramtegning (brug evt.fritzing.org/download)

oTag et billede af robotten og sæt pile og beskrivelser på de enkelte delkomponenter

oHar der været nogle problemer ift. at få hardwaren til at virke?

        Der har været mest problemer med at lys sensorerne har forskellige outputs selv om de har haft samme lys input, vi har været nødt til at skifte sensorer ud, da de første vi brugte havde 300 – 400 forskel i output med samme input.

•Hvordan er robottens opførsel implementeret

oHvad er de overordnede opførsler / metoder for robotten        At måle lysinput og derefter bevæge solcellen og sensorer til højre eller venstre eller resette til “øst”, samt at få de forskellige farver på dioden til at lyse alt efter hvad metode der kører.

oLav et flow-diagram, der beskriver robottens opførsel

oInkludér kode + beskrivelse –Til at formatere og highlighte jeres kode på blog’en kan i bruge plugin’et Enlighter Sourcecode. Sketching-sproget formateres fint med JAVA-indstillingerne!

        #include <Servo.h>

  //setup the initial values.
  Servo servoOne;
  int calibration = 170;
  int trackerPos = 90;
  int error = 0;

  int redPin = 9;
  int greenPin = 10;
  int bluePin = 11;
 
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  //sets the pin for the servo
  servoOne.attach(6);
  //sets the pins for the LED
  pinMode (redPin, OUTPUT);
  pinMode (greenPin, OUTPUT);
  pinMode (bluePin, OUTPUT);
}

//Method for the RGB LED
void RGBcolor(int redLight, int greenLight, int blueLight)
{
  //analogwrite for each pin
  analogWrite(redPin, redLight);
  analogWrite(greenPin, greenLight);
  analogWrite(bluePin, blueLight);
}

void loop() {
  // reads the input on analog pin A0 and A1 (Minus calibration) (value between 0 and 1023)
  int analogValue = analogRead(A0);
  int analogValueTwo = analogRead(A1) - calibration;

  //checks if both values are under 150, if they are resets the solar panel towards east
  if(analogValue<150 && analogValueTwo<150){
    while(trackerPos<=160){
      trackerPos++;
      servoOne.write(trackerPos);
      delay(100);
      RGBcolor(255,0,0);
    }
  }
  //Checks if the light sensor value is more than a set value, if it is turns one way.
  error = analogValue - analogValueTwo;
  if(error>8){
    if(trackerPos<=160){
      trackerPos++;
      servoOne.write(trackerPos);
      RGBcolor(0, 255, 0);
    }
    // checks if the light sensor value is less than a set value, if it is turns the opposite way of the "if" code
 }else if(error<-8){
  if(trackerPos>5){
    trackerPos--;
    servoOne.write(trackerPos);
    RGBcolor(0, 0, 255);
  }
 }
 
  //prints the different values to the console
  Serial.print("First reading = ");
  Serial.print(analogValue);   // the raw analog reading
  Serial.print(" / Second reading = ");
  Serial.println(analogValueTwo);
  Serial.print("error reading: ");
  Serial.println(error);
  Serial.print("servoPos: ");
  Serial.println(trackerPos);

  //delays the loop with 0.3 second
  delay(300);
}

oVis grafer for testkørsel med rigtig sol.

Ud over vores graf har vi tjekket vinklen på solar tracker MAK1, i forhold til den vinkel solen havde ved addressen det blev testet på.

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

        Den største udfordring var at finde ud af hvad for en kalibrering der skulle bruges til de valgte sensorer, især da dette skiftede hver gang systemet blev startet op efter at have været afbrudt. 

•Konklusion

oLøser robotten opgaven ift. opgaveformuleringen?

Robotten løser opgaven ift. opgaveformuleringen, da solcellen bevæges alt efter solens position, og LED lampen lyser i en given farve efter robottens status.

oPå hvilke punkter kan den forbedres –og evt. hvordan?

Fjerne lyssensorerne og bruge mapping system i stedet for.

Ved fortsat brug af lyssensorer, bør opsætningen laves 2-akset for bedre placering af solcellen ift lysinput.

der bør desuden være en “væg” i de huller hvor sensorerne er placeret for at sikre at benene ikke kortslutter og får systemet til at læse “maks værdi”

•Video

oInkludér demo-video. Det er fint at benytte en anden lyskilde end solen for at speede processen op ;-)God fornøjelse!

More