Viktig kunskap

1. Bygga basen

Följande kommer att gå över monteringen av roboten.

1.1 Nedre bas

LCD-skärmen är monterad på bottenplattan med korta avståndsstänger. Batterihållaren är monterad med bult och mutter.

Arduino Uno är monterad på bottenplattan med de korta distansstängerna.

Modulen har ett självhäftande lim på baksidan, dess skyddsfilm tas bort och modulen monteras på basen som visas på bilden nedan.

Montera nu de medellånga sexkantsdistanserna på basen av Soltracker.

1.2 Övre bas

Fäst nu sensorerna på plattan som visas nedan. Plattan är symmetrisk så orienteringen är inte viktig här, men observera positionen för de enskilda sensorerna.

Bilden nedan visar den färdiga installationen av sensorerna.

Montera nu de långa sexkantsdistanserna på plattan med sensorerna.

Fäst nu plattan med alla sensorer i basen där LCD-skärmen, Arduino Uno och batterihållare är monterade.

Lägg i de fyra skärmningsplattorna bredvid varje fotoresistor.

Basen är nu klar och nästa steg kan börja.

2. Servosektion

Nu påbörjas konstruktionen av den vridbara armen, som gör att solcellen kan rotera och luta.
Var noga med att granska de två inställningskoderna för de två servon före montering

 # include <Servo.h>
 Servo lr_servo; //definiera namnet på servo som roterar åt höger och vänster
 int lr_angle = 90 ; //ställ in den initiala vinkeln till 90 grader, ställ in den initiala vinkeln på 90 grader
 const byte lr_servopin = 9 ; //definiera namnet på servo som roterar uppåt och nedåt och dess kontrollstift
 
void setup () {
 lr_servo. bifoga (lr_servopin); // ställ in kontrollstiftet på servo
 lr_servo. skriv (lr_angle); //återgå till initial vinkel
 fördröjning ( 1000 );
 }
 void loop () {}

Se till att du väljer några av skruvarna som är tunna och korta.

 # include <Servo.h> 
Servo out_servo; //definiera namnet på servo som roterar åt höger och vänster
 int ud_angle = 10 ; //ställ in den initiala vinkeln till 10 grader; håll solpanelerna upprätt för att upptäcka det starkaste ljuset
 const byte ud_servopin = 10 ; //definiera servo som roterar uppåt och nedåt och dess kontrollstift

 void setup () { 
out_servo. bifoga (out_servopin); // ställ in kontrollstiftet på servo
 out_servo. skriv (ut_vinkel);
 fördröjning ( 1000 );
 }

 void loop () {}

Nu när den övre servo är återställd, montera den enligt bilden nedan.

Montera nu foten som servodelen är monterad på.

Bilden nedan visar hur man skruvar fast servofoten på servodelen. Kom ihåg att spänna fast.

Nu är hela servodelen monterad och du kan nu montera servodelen på basen.

3. Solcellssektion

För att montera solcellen på servodelen måste elementen nedan monteras varefter solcellen limmas på.

Nu monteras ljusintensitetssensorn på plattan innan solcellen limmas på.

Efter montering av solcellsdelen kan den monterade och färdiga lösningen ses här.

4. Multifunktionell kod

Nedan finns en kodsnutt som du kan programmera din Arduino med och få alla smarta funktioner som roboten innehåller. Koden ser till att roboten reglerar solcellen mot punkten med störst ljus samtidigt som den avläser temperatur, luftfuktighet och ljusintensitet.

 /*
 keystudio sun_follower
 lektion 11
 sun_follower
 http://www.keyestudio.com
 */
 # include <Wire.h>
 # include <LiquidCrystal_I2C.h> 
LiquidCrystal_I2C lcd( 0x27 , 16 , 2 );

 # include <BH1750.h>
 BH1750 ljusmätare;

 # include <dht11.h> //inkludera bibliotekskoden:
 dht11 DHT;
 # definiera DHT11_PIN 7 //definiera DHT11 som det digitala stiftet 7

 # include <Servo.h> 
Servo lr_servo; //definiera namnet på servo som roterar åt höger och vänster
 Servo out_servo; //definiera namnet på servo som roterar uppåt och nedåt

 const byte interruptPin = 2 ; //knappen på knappen; korruptionen är störd

 int lr_angle = 90 ; //ställ in den initiala vinkeln till 90 grader 
int ud_angle = 10 ; //ställ in den initiala vinkeln till 10 grader; håll solpanelerna upprätt för att upptäcka det starkaste ljuset
 int l_tillstånd = A0; //definiera den analoga spänningsingången för fotomotstånden
 int r_state = A1;
 int u_tillstånd = A2;
 int d_state = A3; 
const byte summer = 6 ; //ställ stiftet på summern till digital stift 6
 const byte lr_servopin = 9 ; //definiera styrsignalstiftet för servo som roterar åt höger och vänster
 const byte ud_servopin = 10 ; //definiera styrsignalstiftet för servo som roterar medurs och moturs
 
osignerad int light; //spara variabeln för ljusintensitet
 byte error = 15 ; //Definiera felintervallet för att förhindra vibrationer
 byte m_hastighet = 10 ; //ställ in fördröjningstid för att justera hastigheten på servo; ju längre tid, desto mindre hastighet 
byteupplösning = 1 ; //ställ in rotationsnoggrannheten för servo, den minsta rotationsvinkeln
 int temperatur; //spara variabeln temperatur
 int fuktighet; //spara variabeln luftfuktighet

 void setup () { 
Seriell . börja ( 9600 ); //definiera den seriella baudhastigheten
 // Initiera I2C-bussen (BH1750-biblioteket gör inte detta automatiskt)
 Tråd . Börja ();
 ljusmätare. Börja ();

 lr_servo. bifoga (lr_servopin); // ställ in kontrollstiftet på servo
 out_servo. bifoga (out_servopin); // ställ in kontrollstiftet på servo 
pinMode (l_state, INPUT ); //ställ in läget för pin
 pinMode (r_state, INPUT );
 pinMode (u_state, INPUT );
 pinMode (d_state, INPUT );

 pinMode (interruptPin, INPUT_PULLUP ); //knappstiftet är inställt på input pull-up-läge 
attachInterrupt (digitalPinToInterrupt(interruptPin), adjust_resolution, FALLING); //external interrupt touch-typ är fallande kant; adjust_resolution är avbrottstjänstens funktion ISR

 lcd.init(); // initiera LCD-skärmen
 lcd.backlight(); //ställ in LCD-bakgrundsbelysning

 lr_servo. skriv (lr_angle); //återgå till initial vinkel
 fördröjning ( 1000 );
 out_servo. skriv (ut_vinkel);
 fördröjning ( 1000 );

 }
 
void loop () {
 ServoAction(); //servo utför åtgärden
 read_light(); //läs ljusintensiteten för bh1750
 read_dht11(); //läs värdet på temperatur och luftfuktighet
 LcdShowValue(); //Lcd visar värden för ljusintensitet, temperatur och luftfuktighet

 //erial monitor visar fotoresistorns resistans och servovinkeln
 /*Serial.print(" L ");
 Serial.print(L);
 Serial.print(" R ");
 Serial.print(R);
 Serial.print(" U ");
 Serial.print(U);
 Serial.print(" D ");
 Serial.print(D);
 Serial.print(" ud_angle "); 
Serial.print(out_angle);
 Serial.print(" lr_angle ");
 Serial.println(lr_angle);*/
 // delay(1000);//Under testet tas serieportdata emot för snabbt, och det kan justeras genom att lägga till fördröjningstid */
 }

 /*************funktionen hos servo*************/
 void ServoAction(){
 int L = analogRead (l_state); //avläs det analoga spänningsvärdet för sensorn, 0-1023
 int R = analogRead (r_state); 
int U = analogRead (u_state);
 int D = analogRead (d_state);
 /******************** systemjustering vänster och höger sekvens******************** */
 // abs() är den absoluta värdefunktionen
 if ( abs (L - R) > error && L > R) { //Fastställ om felet ligger inom det acceptabla området, annars justera styrväxeln
 lr_angle -= upplösning; //minska vinkeln 
// lr_servo.attach(lr_servopin); // anslut servo
 if (lr_angle < 0 ) { //begränsa servos rotationsvinkel
 lr_angle = 0 ;
 }
 lr_servo. skriv (lr_angle); //output vinkeln på servo ut vinkeln på servo
 fördröjning (m_hastighet);

 } 
else if ( abs (L - R) > error && L < R) { //Fastställ om felet ligger inom det acceptabla området, annars justera styrväxeln
 lr_angle += upplösning; //Öka vinkeln
 // lr_servo.attach(lr_servopin); // anslut servo
 if (lr_angle > 180 ) { //begränsa servos rotationsvinkel
 lr_angle = 180 ;
 } 
lr_servo. skriv (lr_angle); //mata ut vinkeln på servo
 fördröjning (m_hastighet);

 }
 else if ( abs (L - R) <= error) { //Fastställ om felet ligger inom det acceptabla området, annars justera styrväxeln
 // lr_servo.detach(); //släpp stiftet på servo
 lr_servo. skriv (lr_angle); //mata ut vinkeln på servo
 } 
/********************system som justerar upp och ner************************* /
 if ( abs (U - D) > error && U >= D) { //Fastställ om felet ligger inom det acceptabla området, annars justera styrväxeln
 ud_angle -= upplösning; //minska vinkeln
 // ud_servo.attach(ud_servopin); // anslut servo
 if (ud_angle < 10 ) { //begränsa servos rotationsvinkel
 ut_vinkel = 10 ;
 } 
out_servo. skriv (ut_vinkel); //mata ut vinkeln på servo
 fördröjning (m_hastighet);

 }
 else if ( abs (U - D) > error && U < D) { //Fastställ om felet ligger inom det acceptabla området, annars justera styrväxeln
 ud_angle += upplösning; //Öka vinkeln
 // ud_servo.attach(ud_servopin); // anslut servo 
if (ud_angle > 90 ) { //begränsa servos rotationsvinkel
 ut_vinkel = 90 ;
 }
 out_servo. skriv (ut_vinkel); //mata ut vinkeln på servo
 fördröjning (m_hastighet);

 }
 else if ( abs (U - D) <= error) { //Fastställ om felet ligger inom det acceptabla intervallet. Om det är det, håll det stabilt och gör ingen förändring i vinkeln 
// ud_servo.detach(); //släpp stiftet på servo
 out_servo. skriv (ut_vinkel); //mata ut vinkeln på servo
 }
 }

 void LcdShowValue() {
 char strl[ 5 ];
 char str2[ 2 ];
 char str3[ 2 ];
 dtostrf(ljus, -5 , 0 , str1); //Formatera ljusvärdesdata som en sträng, vänsterjusterad 
dtostrf(temperatur, -2 , 0 , str2);
 dtostrf(fuktighet, -2 , 0 , str3);
 //LCD1602-skärm
 //visa värdet på ljusintensiteten
 lcd. setCursor ( 0 , 0 );
 lcd. print ( "Ljus:" );
 lcd. setCursor ( 6 , 0 );
 lcd. print (strl); 
lcd. setCursor ( 11 , 0 );
 lcd. print ( "lux" );

 //visa värdet på temperatur och luftfuktighet
 lcd. setCursor ( 0 , 1 );
 lcd. print (temperatur);
 lcd. setCursor ( 2 , 1 );
 lcd. print ( "C" ); 
lcd. setCursor ( 5 , 1 );
 lcd. tryck (fuktighet);
 lcd. setCursor ( 7 , 1 );
 lcd. print ( "%" );

 //visa rotationsnoggrannheten
 lcd. setCursor ( 11 , 1 );
 lcd. print ( "res:" ); 
lcd. setCursor ( 15 , 1 );
 lcd. print (upplösning);
 /*if (ljus < 10) {
 lcd.setCursor(7, 0);
 lcd.print(" ");
 lcd.setCursor(6, 0);
 lcd.print(light);
 } annat om (ljus < 100) {
 lcd.setCursor(8, 0);
 lcd.print(" ");
 lcd.setCursor(6, 0);
 lcd.print(light);
 } annat om (ljus < 1000) {
 lcd.setCursor(9, 0);
 lcd.print(" ");
 lcd.setCursor(6, 0);
 lcd.print(light);
 } annat om (ljus < 10 000) {
 lcd.setCursor(9, 0);
 lcd.print(" ");
 lcd.setCursor(6, 0);
 lcd.print(light);
 } annat om (ljus < 100 000) {
 lcd.setCursor(10, 0);
 lcd.print(" ");
 lcd.setCursor(6, 0);
 lcd.print(light);
 }*/
 }

 void read_light(){ 
light = lightMeter.readLightLevel(); //läs ljusintensiteten detekterad av BH1750
 }

 void read_dht11(){
 int check;
 chk = DHT. läsa (DHT11_PIN); // läsa data
 switch (chk) {
 fall DHTLIB_OK:
 ha sönder
 case DHTLIB_ERROR_CHECKSUM: //kontrollera och returnera fel
 ha sönder 
fall DHTLIB_ERROR_TIMEOUT: //Timeout och returfel
 ha sönder
 standard :
 ha sönder
 }
 temperatur = DHT.temperatur;
 fuktighet = DHT.fuktighet;
 }

 /*************funktionen stör tjänsten******************/
 void adjust_resolution() {
 ton (summer, 800 , 100 );
 fördröjning ( 10 ); //delay för att eliminera vibrationer 
if (! digitalRead (interruptPin)){
 if (upplösning < 5 ){
 upplösning++;
 } annat {
 upplösning = 1 ;
 }
 }
 }