Af Louise Præstiin Jepsen og Victor Størner-Ryberg

Systembeskrivelse:
Systemet består af to LDR-modstande med en plade imellem dem. Disse lysdioder er forbundet med en Arduino, som modtager deres data. Derudover er Arduinoen forbundet til en H-bro som gør det muligt at skifte Lego DC-motorens retning. Motoren får strøm fra et 9V batteri som går igennem en 5V spændingsregulator. På denne måde sikres det at der kun går en spænding på 5V igennem motorsystemet og H-broen.  

Figur 1: Dette billede viser den elektroniske opstilling i Tinkercad

Begrundelse for opbygning:

Den elektroniske del af vores opbygning kan ses på figur 1. Vi valgte at dele opbygningen op i to dele, for at gøre opstillingen mere overskuelig at arbejde med. Til hver af LDR-modstandene og lysdioderne er der en modstand, for at sikre at lysdioderne ikke springes og at vi ikke laver en kortslutning.  Det skal nævnes at LDR-modstandene ikke ville være på breadboardet hvis vi skulle fremstille vores produkt fysisk. Derimod ville de placeres på pladen med solpanelet, så de kan diagere panelet. Derudover ville de være opdelt med en mindre plade, hvilket ville skabe en skygge når solen bevæger sig.

For at få motoren til at rotere den modsatte retning havde vi brug for at kunne ændre strømmens retning. Derfor anvendte vi en H-bro opstilling. Vores H-bro består af fire MOSFET transistors. Disse transistors danner hvert et par som kan lede strømmen i deres retning og ved hjælp af vores Arduino kan vi programmere hvilke af vores transistors der skal sendes strøm igennem.

Alt programmerings relateret kan findes under Code undermenuen i Tinkercad (link kan findes i demonstrations video afsnittet) eller nederst på selve blogsiden. Selve koden er opbygget omkring 3 forskellige modes. Adjusting, standby og reset mode. Disse er henholdsvis koblet til gul, rød og blå LED. Programmet starter altid i reset mode, hvor der næsten ikke modtages noget lys, dette mode vises med den blå LED. I tilfælde at en af værdierne givet fra de to LDR-modstande bliver for høj i forhold til den anden (50+), så vil motoren begynde at rotere enten øst eller vest ud fra hvilken modstand der mangler lys. Dette indikeres med en gul LED. Når så begge LDR-modstande giver ca. den samme værdi så vil programmet skifte til standby mode, hvor motoren nu står stille, og den røde lysdiode vil være tændt. Størstedelen af styringen er opbygget med if statements. Hovedfunktionaliteten kan ses som et diagram nedenfor.

Figur 2: Dette er et flow-diagram som viser sammensætningen mellem LDR-modstandene, kode og lysdioderne

Som kode eksempel er der vores reset mode. I selve koden bliver værdierne fra vores LDR-modstande sammenlignet med et opstillet threshhold som ligger på 7. Hvis værdien er under 7, (dvs. et meget mørkt rum), så tændes der for den blå LED, og motoren begynder at rotere meget langsomt mod øst.

Figur 3: Ovenstående billeder viser den del af koden som resetter systemet

For at simulere en blød opstart på motoren, så har vi valgt at bruge et for-loop i vores adjusting mode. Dette for-loop øger hastigheden over mange iterationer med ca. 5. Selve for-loopet køres kun en enkelt gang, hvorefter motoren roterer med dens maksimale hastighed.

Figur 4: Dette viser det for loop der bruges til at lave en “blød opstart”.

Resten af koden er meget lignende koden til enten reset mode eller adjusting mode, bare med nogle få ændringer.

Den mekaniske del af opbygning har vi ikke kunne fremstille pga. mangel på materialer. Vi tegnede dog et udkast til hvordan gearingen kunne fungere med vores motor. Figur 1 viser opstillingen set forfra. Solpanelet kan ikke vises, da det ville skærme det meste af gearingen. Til opstillingen har vi valgt at anvende skråtandhjul, for at for den horisontale rotation til at blive vertikal. Derudover ville vi anvende et større tandhjul som skulle modtage kraften, så hastigheden sænkes. På stangen som det store tandhjul roterer, er der fastsat en legoklods der holder endnu en stang, hvorpå sol panelet sidder.

Figur 5: Den mekaniske opsætning set forfra

Figur 2 viser samme opstilling bare set fra højre side. Dette skulle gerne hjælpe med at illustrere hvordan opbygningen hænger sammen i forhold til sol panelet.

Figur 6: Dette er samme opsætning set fra siden

Demonstrations video

Link til videoen: https://www.youtube.com/watch?v=szjbUwigg2M&feature=youtu.be
Link til tinkercad opstilling: https://www.tinkercad.com/things/4Tm8he94poB-sun-tracker-new/editel?sharecode=nwDD83oaHiwmf9Ahwsb76q2BOvGoovyy-ebD6jlMRQc=

Denne video viser en simulering af vores elektroniske del. Det første der bliver vist i videoen er når den ene LDR-sensor bliver påvirket, og motoren drejer mod venstre. Derefter bliver LDR-modstandene sat til samme værdi, og motoren går på standby. Den anden LDR-modstand bliver så ændret, så motoren drejer mod højre. I videoen viser de forskellige lysdioder også systemets status.

Konklusion

Det er svært for os at sige hvorvidt den mekaniske del af robotten ville fungere som den skulle. Det samme gælder robotten som helhed, eftersom vi kun har kunne teste den elektroniske del vha. simuleringsprogrammet Tinkercad. Dog virker vores simulering næsten helt optimalt, så reelt bør det kunne implementeres ind i et rigtigt produkt. Gearingen er i sig selv meget simpelt, dog ved vi ikke hvorvidt vi ville have skråtandhjul til rådighed, hvis den skulle bygges af Lego.

Overordnet opfylder vores simulering næsten alle krav. Det eneste der ikke virker som det skal er at motoren ikke laver en blød opstart ved den ene LDR-modstand. Hvorfor det virker ved den ene og ikke den anden er vi usikre på. Det kunne være en fejl i simuleringen eller en fejl i vores opsætning/kode. I forhold til forbedringer, så er Arduinoen programmeret sådan at den bliver ved med at dreje motoren indtil begge LDR-modstande har omkring samme værdi. Den stopper altså ikke ved 180 grader. Man kunne udregne hvor lang tid det ville tage for den at nå 180 grader og så programmere det ud fra dette. Det er dog ikke muligt for os da vi ikke har en fysisk prototype at tage tid på.

Koden til til solsensoren kan ses nedenfor:

#define motorpin1 11  /* output pin for the motor (counterclockwise) */
#define motorpin2 12  /* output pin for the motor (clockwise) */

#define adjustingLedPin 3 /* Yellow LED used to signal adjusting mode of platform */
#define standbyLedPin 4 /* Red LED used to signal standby mode of platform */
#define resetLedPin 2 /* Blue LED used to signal reset mode of platform */

void setup() /* setup */
{
  pinMode(adjustingLedPin, OUTPUT); /* setup for adjusting led */
  pinMode(standbyLedPin, OUTPUT); 	/* setup for standby led */
  pinMode(resetLedPin, OUTPUT); /*setup for reset led */
  
  pinMode(motorpin1, OUTPUT); /* setup for motor */
  pinMode(motorpin2, OUTPUT); 
  
  analogWrite (motorpin1, 0); /* ensure no spin on motor */
  analogWrite (motorpin2, 0); 
  
  Serial.begin(9600);  /* just for debugging console */
}

void loop() /* main loop */
{
  //Photoresistor readings
  int sensorValueE = analogRead(A1); //Value from east
  int sensorValueW = analogRead(A0); //Value from west
  
  int sleepModeThreshhold = 7; //Thresshold which is used to reset the platform when there is no light
  
 // Serial.println(sensorValueE); //Print value of sensor in console
//  Serial.println(sensorValueW); //Print value of sensor in console
  
  bool doneSpinningEast; //Used to check if the spinup is done
  bool doneSpinningWest; //Used to check if the spinup is done
  
  //Photoresistor diffrences calc used for adjusting + threshold
  int higherVal; //Used to hold the current highest value from photoresistor
  int lowerVal;  //Used to hold the current lowest value from photoresistor
  int diffBetweenVal; //Used to hold the diffrences between highest and lowest value from photoresistor
  int threshhold = 50; //Threshhold to keep platform from constantly moving
    
  if (sensorValueE >= sensorValueW) //Check which value is higher, east or west
  {
    higherVal = sensorValueE; //East is highest
    lowerVal = sensorValueW;  //West is lowest
    diffBetweenVal = higherVal - lowerVal; //Calc diffrence between them. 
  }
  else //If east value is lower than west do following
  {
    higherVal = sensorValueW; //East is lowest
    lowerVal = sensorValueE;  //West is highest
    diffBetweenVal = higherVal - lowerVal; //Calc diffrence between them. 
  }
  
  //Motor standby mode
  
  if(diffBetweenVal < threshhold && sensorValueW > sleepModeThreshhold && sensorValueE > sleepModeThreshhold){ //if diffrence between sensors does not surpass the threshold, do following.
    //  Serial.println("Sensors are about equal"); //Console message
  	  doneSpinningWest = false; //reset this value so it is possible to spin west when needed
      doneSpinningEast = false; //reset this value so it is possible to spin east when needed
      digitalWrite(adjustingLedPin, LOW); //Turn off adjusting mode led

      analogWrite(motorpin2, 0); //Stops motor
      analogWrite(motorpin1, 0); //Stops motor
      digitalWrite(standbyLedPin, HIGH); //indicate standby mode with red led
  }
  
  
  //Motor adjust mode
  
  //adjusting motor towards east
  if(sensorValueE < sensorValueW && diffBetweenVal >= threshhold) //if east value is lower and diffrence between east and west is too great do the following
  {   
      doneSpinningWest = false; //reset this value so it is possible to spin west when needed
      
      digitalWrite(standbyLedPin, LOW); //Turn off standby mode led
      digitalWrite(resetLedPin, LOW); //Turn off reset mode led

      Serial.println("moving towards east"); //Debug console message
      analogWrite(motorpin2, 0);   //No spin other direction
    
      //Soft startup
      
      if(doneSpinningEast != true) //if it hasnt spun yet, do the following.
      {
      for (int speedVal = 0; speedVal <= 255; speedVal +=5) {
      	analogWrite(motorpin1, speedVal); //Spin (counterclockwise)
        
        delay(30);
      }
      digitalWrite(adjustingLedPin, HIGH); //indicate adjusting mode with yellow led
      doneSpinningEast = true; //Done spinning
      }

  }

  //adjusting motor towards west 
  if(sensorValueW < sensorValueE && diffBetweenVal >= threshhold)//if west value is lower and diffrence between east and west is too great do the following
  {   
      doneSpinningEast = false; //reset this value so it is possible to spin east when needed
      
      digitalWrite(standbyLedPin, LOW); //Turn off standby mode led
      digitalWrite(resetLedPin, LOW); //Turn off reset mode led
  	  
      Serial.println("moving towards west"); //Debug console message
  	  analogWrite(motorpin1, 0);   //No spin other direction
      
      //Soft startup
     
      if(doneSpinningWest != true) //if it hasnt spun yet, do the following
      {
      for (int speedVal = 0; speedVal <= 255; speedVal +=5) {
      	analogWrite(motorpin2, speedVal); //Spin (clockwise)
        Serial.println(speedVal);
        delay(30);
      }
        digitalWrite(adjustingLedPin, HIGH); //indicate adjusting mode with yellow led

      doneSpinningWest = true; //Done spinning  
      }
  }
    
  //Reset code
  if(sensorValueW < sleepModeThreshhold && sensorValueE < sleepModeThreshhold) //if there is no light do the following
  {
  digitalWrite(standbyLedPin, LOW); //Turn off standby mode led
  digitalWrite(adjustingLedPin, LOW); //Turn off adjusting mode led
  Serial.println("Reseting"); //Debug console message
  analogWrite(motorpin2, 0); //Slow spin for a reset (counterclockwise)

  analogWrite(motorpin1, 10); //Slow spin for a reset (counterclockwise)
  digitalWrite(resetLedPin, HIGH); //indicate reset mode with blue led
  }
                  
  delay(300);      
}

Leave a Reply