Arduino Forum

International => Deutsch => Topic started by: newpv on Sep 09, 2020, 07:59 pm

Title: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 09, 2020, 07:59 pm
Hallo,
ich bin neu beim Programmieren und möchte gerne ein Programm erstellen mit 2 Beweglichen Achsen für die Sonne verfolgung. Habe nach Vorlage gearbeitet! Das Problem ist jetzt ich muss ja 2x die Differenz ausrechnen. 1x zwischen dem LDR links-rechts und 1x zwischen dem LDR oben-unten. bekomme aktuell eine Fehlermeldung, da ich nich weiß wie ich diese unterschiedlich diffieren/bennen kann.
Hier das Programm:
Code: [Select]
// Servo-Library einbinden
#include <Servo.h>

// Servo-Objekt horizontal erzeugen, Motor rechts-links
Servo horizontal;

// Startwinkel für den Servo horizontal (Bereich 0-179 Grad)
int servoh = 90;

// Servo-Objekt vertikal erzeugen, Motor oben-unten
Servo vertikal;

// Startwinkel für den Servo vertikal (Bereich 0-90 Grad)
int servov = 45;


void setup() {
 // Serielle Schnittstelle initialisieren
 Serial.begin(9600);
 // Pin 5 PWM als Ausgabe-Pin
 pinMode(5, OUTPUT);
 // Pin 5 PWM ist Steuerpin für den Servo horizontal, Motor rechts-links
 horizontal.attach(5);
 horizontal.write(servoh);
 delay(20);
 // Pin 6 PWM als Ausgabe-Pin
 pinMode(6, OUTPUT);
 // Pin 6 PWM ist Steuerpin für den Servo vertikal, Motor oben-unten, Startwinkel setzen und warte Zeit
 vertikal.attach(6);
 vertikal.write(servov);
 delay(20);
}

void loop() {

 // Helligkeit der 2 lichtempfindlichen Widerstände für horizontal auslesen (Rechts)
 int rightEye = analogRead(0);
 // Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind (Links)
 int leftEye = analogRead(1) * 1.0;

 // Differenz horizontal ausrechnen
 int diff = (rightEye - leftEye);

 // Wenn rechts deutlich heller als links -> 2 Grad nach rechts drehen
 if (diff > 20) {
   servoh = servoh + 2;
 }

 // Wenn links deutlich heller als rechts -> 2 Grad nach links drehen
 if (diff < -20) {
   servoh = servoh - 2;
 }

 // Servo horizontal max. bis 179 Grad drehen
 if (servoh > 179) {
   servoh = 179;
 }

 // Servo horizontal min. bis 0 Grad drehen
 if (servoh < 0) {
   servoh = 0;
 }

 // Grad an den Servo horizontal schicken
 horizontal.write(servoh);

 // Warte Zeit bis der Servo horizontal gefahren ist
 delay(100);

 // Helligkeit der 2 lichtempfindlichen Widerstände für vertikal auslesen (Oben)
 int aboveEye = analogRead(2);
 // Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind (Unten)
 int belowEye = analogRead(3) * 1.0;

 // Differenz vertikal ausrechnen
 int diff = (aboveEye - belowEye);

 // Wenn oben deutlich heller als unten -> 2 Grad nach oben drehen
 if (diff > 20) {
   servov = servov + 2;
 }

 // Wenn unten deutlich heller als oben -> 2 Grad nach unten drehen
 if (diff < -20) {
   servov = servov - 2;
 }

 // Servo vertikal max. bis 90 Grad drehen
 if (servov > 90) {
   servov = 90;
 }

 // Servo vertikal min. bis 0 Grad drehen
 if (servov < 0) {
   servov = 0;
 }

 // Grad an den Servo horizontal schicken
 vertikal.write(servov);

 // Die beiden Helligkeitswerte zu Testzwecken an den PC übertragen
 Serial.println(String(rightEye) + "-" + String(leftEye));
 Serial.println(String(aboveEye) + "-" + String(belowEye));

 // Kurze Wartezeit, dann nächste Messung.
 // Sollte es beim Testen der Einstellungen zu chaotisch werden,
 // diesen Wert einfach auf 50 oder 100 erhöhen und damit den Vorgang verlangsamen
 delay(20);
}

PS.: Die Zeiten werden natürlich noch angepasst, ist erstmal zum testen!
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Tommy56 on Sep 09, 2020, 08:08 pm
Und wo ist die Fehlermeldung? (Bitte die auch in Codetags)

Gruß Tommy
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Peter-CAD-HST on Sep 09, 2020, 08:16 pm
Moin newpv

Mal ne schnelle Frage:
Warum nimmst du keine lokale Uhr um den Sonnenstand zu verfolgen?

Gruss Peter
und gesund bleiben
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: uwefed on Sep 09, 2020, 08:50 pm
Code: [Select]
Serial.println(String(rightEye) + "-" + String(leftEye));
 Serial.println(String(aboveEye) + "-" + String(belowEye));

Was soll der Sch... mit Strings um 2 Zahlen mit einem Strich in der Mitte auszugeben?

Code: [Select]
Serial.print(rightEye);
Serial.print(" - ");
Serial.println(leftEye);

macht das viel besser.

Die Servo-Bibliothek kann auf jeden Pin den Servo ansteuern. Es müssen keine PWM Pins sein.
Außerdem müssen diese Pins auch nicht mit pinMode initialisiert werden. Das macht die Bibliothek.
Also lösche pinMode();

Die Fehlermeldung möchte ich auch gerne sehen. Ich kann sie nämlich nicht erraten.

Grüße Uwe
 
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: michael_x on Sep 09, 2020, 11:59 pm
Quote
int diff = ...
Vermutlich meckert der Compiler beim zweiten Mal, dass diff schon definiert ist.

Entweder du definierst eine zweite Variable, mit anderem Namen,
oder du verwendest die bereits definierte nochmal.
Code: [Select]

   ...
  // Differenz vertikal ausrechnen
  diff = (aboveEye - belowEye);
  ...
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 10, 2020, 04:07 pm
Danke für eure Antworten!

Vermutlich meckert der Compiler beim zweiten Mal, dass diff schon definiert ist.
Genau das ist es!

Quote
exit status 1
redeclaration of 'int diff'
Wäre dieser Code besser geeignet?
Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo horizontal; // Horizontale Servo
int servoh = 90; // Horizontale Servo stehen

Servo vertikal; // Vertikale Servo
int servov = 90; // Vertikale Servo stehen

// LDR Stiftverbindungen
// Name = analogpin;
int ldrlt = 0; // LDR oben links
int ldrrt = 1; // LDR ober rechts
int ldrld = 2; // LDR unten links
int ldrrd = 3; // LDR unten recht

Leere setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  horizontal.attach (9);
  vertical.attach (10);
}

Leere Schleife ()
{
  int lt = analogRead (ldrlt); // oben links
  int rt = analogRead (ldrrt); // oben rechts
  int ld = analogRead (ldrld); // unten links
  int rd = analogRead (ldrrd); // unten rigt

  int dtime = analogRead (4) / 20; // Lesen Potentiometer
  int tol = analogRead (5) / 4;

  int avt = (LT + RT) / 2; // Mittelwert top
  int avd = (ld + rd) / 2; // Mittelwert nach unten
  int avl = (lt + ld) / 2; // Mittelwert links
  int avr = (RT + rd) / 2; // Mittelwert rechts

  int DVERT = avt - avd; // Überprüfen Sie die diffirence zwischen oben und unten
  int dhoriz = avl - avr; // überprüfen Sie die diffirence zwischen links und rechts

  if (-1 * tol > DVERT || DVERT > tol) // überprüfen, ob die diffirence im Toleranz anderes ändern vertikalen Winkel
  {
    if (avt > avd)
    {
      servov = ++ servov;
      if (servov > 180)
      {
        servov = 180;
      }
    }
    else if (avt < avd)
    {
      servov = --servov;
      if (servov < 0)
      {
        servov = 0;
      }
    }
    vertical.write (servov);
  }

  if (-1 * tol > dhoriz || dhoriz > tol) // überprüfen, ob die diffirence im Toleranz anderes ändern horizontalen Winkel
  {
    if (avl > avr)
    {
      servoh = --servoh;
      if (servoh < 0)
      {
        servoh = 0;
      }
    }
    else if (avl < avr)
    {
      servoh = ++ servoh;
      if (servoh > 180)
      {
        servoh = 180;
      }
    }
    else if (avl == avr)
    {
      // gar nichts
    }
    horizontal.write (servoh);
  }
  Verzögerung (DTIME);
}

// Die 4 Helligkeitswerte zu Testzwecken an den PC übertragen
Serial.print(ldrlt); // LDR oben links
Serial.print(" - ");
Serial.println(ldrrt); // LDR oben rechts
Serial.print(" - ");
Serial.println(ldrld); // LDR unten links
Serial.print(" - ");
Serial.println(ldrrd); // LDR unten rechts

Quelle:
https://www.clickoslo.com/arduino-solar-tracker.html (https://www.clickoslo.com/arduino-solar-tracker.html)

Bin kein Programmierer, lese mich ein und möchte es mit eurer Hilfe verwenden!
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Tommy56 on Sep 10, 2020, 04:27 pm
Da hast Du Dir bei C&P ein böses Zeichen eingefangen.
Öffne den Text mal in einem Editor, bei dem Du zwischen UTF8 und ASCII/ANSI umschalten kannst (z.B. Notepad++). Dann müsstest Du beim Umschalten ein komisches Zeichen sehen, dass Du löschen solltest.

Gruß Tommy
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 10, 2020, 04:47 pm
Habe es versucht, aber leider ist dort kein komisches Zeichen...

Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo horizontal; // Horizontale Servo
int servoh = 90; // Horizontale Servo stehen

Servo vertikal; // Vertikale Servo
int servov = 90; // Vertikale Servo stehen

// LDR Stiftverbindungen
// Name = analogpin;
int ldrlt = 0; // LDR oben links
int ldrrt = 1; // LDR oben rechts
int ldrld = 2; // LDR unten links
int ldrrd = 3; // LDR unten rechts

Leere setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  horizontal.attach (9);
  vertical.attach (10);
}

Leere Schleife ()
{
  int lt = analogRead (ldrlt); // oben links
  int rt = analogRead (ldrrt); // oben rechts
  int ld = analogRead (ldrld); // unten links
  int rd = analogRead (ldrrd); // unten rechts

  int dtime = analogRead (4) / 20; // Lesen Potentiometer
  int tol = analogRead (5) / 4;

  int avt = (LT + RT) / 2; // Mittelwert top
  int avd = (ld + rd) / 2; // Mittelwert nach unten
  int avl = (lt + ld) / 2; // Mittelwert links
  int avr = (RT + rd) / 2; // Mittelwert rechts

  int dvert = avt - avd; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = avl - avr; // Überprüfen der diffirence zwischen links und rechts

  if (-1 * tol > dvert || dvert > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht vertikalen Winkel verändern
  {
    if (avt > avd)
    {
      servov = ++ servov;
      if (servov > 180)
      {
        servov = 180;
      }
    }
    else if (avt < avd)
    {
      servov = --servov;
      if (servov < 0)
      {
        servov = 0;
      }
    }
    vertical.write (servov);
  }

  if (-1 * tol > dhoriz || dhoriz > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht horizontalen Winkel verändern
  {
    if (avl > avr)
    {
      servoh = --servoh;
      if (servoh < 0)
      {
        servoh = 0;
      }
    }
    else if (avl < avr)
    {
      servoh = ++ servoh;
      if (servoh > 180)
      {
        servoh = 180;
      }
    }
    else if (avl == avr)
    {
      // gar nichts
    }
    horizontal.write (servoh);
  }
  Verzögerung (DTIME);
}

// Die 4 Helligkeitswerte zu Testzwecken an den PC übertragen
Serial.print(ldrlt); // LDR oben links
Serial.print(" - ");
Serial.println(ldrrt); // LDR oben rechts
Serial.print(" - ");
Serial.println(ldrld); // LDR unten links
Serial.print(" - ");
Serial.println(ldrrd); // LDR unten rechts


Und wenn ich die Zeile "  Verzögerung (DTIME);" ändere in "Verzoegerung (DTIME);" kommt diese Fehlermeldung:
Code: [Select]
exit status 1
'Leere' does not name a type


Das ist auch das einzige Symbol, was komisch ist, das "ü" bei Verzögerung!
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 10, 2020, 04:58 pm
Habe noch einen Fehler gesehen:
Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo horizontal; // Horizontale Servo
int servoh = 90; // Horizontale Servo stehen

Servo vertikal; // Vertikale Servo
int servov = 90; // Vertikale Servo stehen

// LDR Stiftverbindungen
// Name = analogpin;
int ldrlt = 0; // LDR oben links
int ldrrt = 1; // LDR oben rechts
int ldrld = 2; // LDR unten links
int ldrrd = 3; // LDR unten rechts

Leere setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  horizontal.attach (9);
  vertical.attach (10);
}

Leere Schleife ()
{
  int lt = analogRead (ldrlt); // oben links
  int rt = analogRead (ldrrt); // oben rechts
  int ld = analogRead (ldrld); // unten links
  int rd = analogRead (ldrrd); // unten rechts

  int dtime = analogRead (4) / 20; // Lesen Potentiometer
  int tol = analogRead (5) / 4;

  int avt = (LT + RT) / 2; // Mittelwert top
  int avd = (ld + rd) / 2; // Mittelwert nach unten
  int avl = (lt + ld) / 2; // Mittelwert links
  int avr = (RT + rd) / 2; // Mittelwert rechts

  int dvert = avt - avd; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = avl - avr; // Überprüfen der diffirence zwischen links und rechts

  if (-1 * tol > dvert || dvert > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht vertikalen Winkel verändern
  {
    if (avt > avd)
    {
      servov = ++ servov;
      if (servov > 180)
      {
        servov = 180;
      }
    }
    else if (avt < avd)
    {
      servov = --servov;
      if (servov < 0)
      {
        servov = 0;
      }
    }
    vertical.write (servov);
  }

  if (-1 * tol > dhoriz || dhoriz > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht horizontalen Winkel verändern
  {
    if (avl > avr)
    {
      servoh = --servoh;
      if (servoh < 0)
      {
        servoh = 0;
      }
    }
    else if (avl < avr)
    {
      servoh = ++ servoh;
      if (servoh > 180)
      {
        servoh = 180;
      }
    }
    else if (avl == avr)
    {
      // gar nichts
    }
    horizontal.write (servoh);
  }
  Verzögerung (DTIME);
}

// Die 4 Helligkeitswerte zu Testzwecken an den PC übertragen
Serial.println(String(ldrlt)); // LDR oben links
Serial.println(String(" - "));
Serial.println(String(ldrrt)); // LDR oben rechts
Serial.println(String)(" - ");
Serial.println(String)(ldrld); // LDR unten links
Serial.println(String)(" - ");
Serial.println(String)(ldrrd); // LDR unten rechts


Hier die Komplette Fehlermeldung:
Code: [Select]
Arduino: 1.8.10 (Windows 10), Board: "Arduino/Genuino Uno"

Sonnen_Verfolgung:88:7: error: stray '\303' in program

   Verzögerung (DTIME);

       ^

Sonnen_Verfolgung:88:8: error: stray '\266' in program

   Verzögerung (DTIME);

        ^

Sonnen_Verfolgung:16:1: error: 'Leere' does not name a type

 Leere setup ()

 ^~~~~

Sonnen_Verfolgung:25:1: error: 'Leere' does not name a type

 Leere Schleife ()

 ^~~~~

Sonnen_Verfolgung:16:1: error: 'Leere' does not name a type

 Leere setup ()

 ^~~~~

Sonnen_Verfolgung:25:1: error: 'Leere' does not name a type

 Leere Schleife ()

 ^~~~~

Sonnen_Verfolgung:92:1: error: 'Serial' does not name a type

 Serial.println(String(ldrlt)); // LDR oben links

 ^~~~~~

Sonnen_Verfolgung:93:1: error: 'Serial' does not name a type

 Serial.println(String(" - "));

 ^~~~~~

Sonnen_Verfolgung:94:1: error: 'Serial' does not name a type

 Serial.println(String(ldrrt)); // LDR oben rechts

 ^~~~~~

Sonnen_Verfolgung:95:1: error: 'Serial' does not name a type

 Serial.println(String)(" - ");

 ^~~~~~

Sonnen_Verfolgung:96:1: error: 'Serial' does not name a type

 Serial.println(String)(ldrld); // LDR unten links

 ^~~~~~

Sonnen_Verfolgung:97:1: error: 'Serial' does not name a type

 Serial.println(String)(" - ");

 ^~~~~~

Sonnen_Verfolgung:98:1: error: 'Serial' does not name a type

 Serial.println(String)(ldrrd); // LDR unten rechts

 ^~~~~~

Mehrere Bibliotheken wurden für "Servo.h" gefunden
 Benutzt: C:\Users\...\Documents\Arduino\libraries\Servo
 Nicht benutzt: C:\Users\...\Documents\Arduino\libraries\Servo-1.1.6
 Nicht benutzt: C:\Program
exit status 1
stray '\303' in program

Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Moko on Sep 10, 2020, 05:06 pm
Habe es versucht, aber leider ist dort kein komisches Zeichen...

Code: [Select]


Leere setup ()

Leere Schleife ()


hast Du versucht den Sketch per Google translator zu übersetzen? *g*
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Tommy56 on Sep 10, 2020, 05:13 pm
Doch das ö.

Gruß Tommy
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Moko on Sep 10, 2020, 05:17 pm
Doch das ö.

Gruß Tommy
hieß vor google translate bestimmt noch "delay" statt Verzögerung ;)
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 10, 2020, 05:18 pm
Danke das war Fehler nr.1, habe jetzt delay drin

Dann ist also noch zusätzlich der Fehler bei Leere setup () & Leere Schleife () habe es jetzt geändert in viod setup & void loop...wir kommen weiter :)

Jetzt sieht es so aus:
Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo horizontal; // Horizontale Servo
int servoh = 90; // Horizontale Servo stehen

Servo vertikal; // Vertikale Servo
int servov = 90; // Vertikale Servo stehen

// LDR Stiftverbindungen
// Name = analogpin;
int ldrlt = 0; // LDR oben links
int ldrrt = 1; // LDR oben rechts
int ldrld = 2; // LDR unten links
int ldrrd = 3; // LDR unten rechts

void setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  horizontal.attach (9);
  vertical.attach (10);
}

void loop ()
{
  int lt = analogRead (ldrlt); // oben links
  int rt = analogRead (ldrrt); // oben rechts
  int ld = analogRead (ldrld); // unten links
  int rd = analogRead (ldrrd); // unten rechts

  int dtime = analogRead (4) / 20; // Lesen Potentiometer
  int tol = analogRead (5) / 4;

  int avt = (LT + RT) / 2; // Mittelwert top
  int avd = (ld + rd) / 2; // Mittelwert nach unten
  int avl = (lt + ld) / 2; // Mittelwert links
  int avr = (RT + rd) / 2; // Mittelwert rechts

  int dvert = avt - avd; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = avl - avr; // Überprüfen der diffirence zwischen links und rechts

  if (-1 * tol > dvert || dvert > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht vertikalen Winkel verändern
  {
    if (avt > avd)
    {
      servov = ++ servov;
      if (servov > 180)
      {
        servov = 180;
      }
    }
    else if (avt < avd)
    {
      servov = --servov;
      if (servov < 0)
      {
        servov = 0;
      }
    }
    vertical.write (servov);
  }

  if (-1 * tol > dhoriz || dhoriz > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht horizontalen Winkel verändern
  {
    if (avl > avr)
    {
      servoh = --servoh;
      if (servoh < 0)
      {
        servoh = 0;
      }
    }
    else if (avl < avr)
    {
      servoh = ++ servoh;
      if (servoh > 180)
      {
        servoh = 180;
      }
    }
    else if (avl == avr)
    {
      // gar nichts
    }
    horizontal.write (servoh);
  }
  delay (DTIME);
}

// Die 4 Helligkeitswerte zu Testzwecken an den PC übertragen
Serial.println(String(ldrlt)); // LDR oben links
Serial.println(String(" - "));
Serial.println(String(ldrrt)); // LDR oben rechts
Serial.println(String)(" - ");
Serial.println(String)(ldrld); // LDR unten links
Serial.println(String)(" - ");
Serial.println(String)(ldrrd); // LDR unten rechts


Jetzt sind noch Fehler in der Bennenung
Neue Fehlerausgabe:
Code: [Select]
Arduino: 1.8.10 (Windows 10), Board: "Arduino/Genuino Uno"

E:\Arduino Projekt Solar\Sonnen_Verfolgung\Sonnen_Verfolgung.ino: In function 'void setup()':

Sonnen_Verfolgung:22:3: error: 'vertical' was not declared in this scope

   vertical.attach (10);

   ^~~~~~~~

E:\Arduino Projekt Solar\Sonnen_Verfolgung\Sonnen_Verfolgung.ino:22:3: note: suggested alternative: 'vertikal'

   vertical.attach (10);

   ^~~~~~~~

   vertikal

E:\Arduino Projekt Solar\Sonnen_Verfolgung\Sonnen_Verfolgung.ino: In function 'void loop()':

Sonnen_Verfolgung:35:14: error: 'LT' was not declared in this scope

   int avt = (LT + RT) / 2; // Mittelwert top

              ^~

Sonnen_Verfolgung:35:19: error: 'RT' was not declared in this scope

   int avt = (LT + RT) / 2; // Mittelwert top

                   ^~

Sonnen_Verfolgung:61:5: error: 'vertical' was not declared in this scope

     vertical.write (servov);

     ^~~~~~~~

E:\Arduino Projekt Solar\Sonnen_Verfolgung\Sonnen_Verfolgung.ino:61:5: note: suggested alternative: 'vertikal'

     vertical.write (servov);

     ^~~~~~~~

     vertikal

Sonnen_Verfolgung:88:10: error: 'DTIME' was not declared in this scope

   delay (DTIME);

          ^~~~~

E:\Arduino Projekt Solar\Sonnen_Verfolgung\Sonnen_Verfolgung.ino: At global scope:

Sonnen_Verfolgung:92:1: error: 'Serial' does not name a type

 Serial.println(String(ldrlt)); // LDR oben links

 ^~~~~~

Sonnen_Verfolgung:93:1: error: 'Serial' does not name a type

 Serial.println(String(" - "));

 ^~~~~~

Sonnen_Verfolgung:94:1: error: 'Serial' does not name a type

 Serial.println(String(ldrrt)); // LDR oben rechts

 ^~~~~~

Sonnen_Verfolgung:95:1: error: 'Serial' does not name a type

 Serial.println(String)(" - ");

 ^~~~~~

Sonnen_Verfolgung:96:1: error: 'Serial' does not name a type

 Serial.println(String)(ldrld); // LDR unten links

 ^~~~~~

Sonnen_Verfolgung:97:1: error: 'Serial' does not name a type

 Serial.println(String)(" - ");

 ^~~~~~

Sonnen_Verfolgung:98:1: error: 'Serial' does not name a type

 Serial.println(String)(ldrrd); // LDR unten rechts

 ^~~~~~

Mehrere Bibliotheken wurden für "Servo.h" gefunden
 Benutzt: C:\Users\...\Documents\Arduino\libraries\Servo
 Nicht benutzt: C:\Users\...\Documents\Arduino\libraries\Servo-1.1.6
 Nicht benutzt: C:\Program
exit status 1
'vertical' was not declared in this scope

Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Moko on Sep 10, 2020, 05:20 pm
was soll Verzögerung sein?
wenn, dann delay (auch wenn es nicht schön ist)
und

void setup()
void loop()
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Tommy56 on Sep 10, 2020, 05:21 pm
Wenn ich das ö andere in oe geht es auch noch nicht...

Dann ist also noch zusätlich der Fehler bei Leere setup () & Leere Schleife ()
Das ö musst Du aber ändern. Das "Leere setup()" habe ich für einen Witz gehalten. Ich wäre nie auf den Gedanken gekommen, dass jemand sowas wirklich macht.

Gruß Tommy

Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 10, 2020, 05:28 pm
Bin leider im Programmieren nicht so fit...habe es als Vorlage genommen und möchte es zum laufen bringen!

Denke das bekomme ich mit eurer Hilfe hin! Danke schonmal!
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: michael_x on Sep 11, 2020, 01:47 pm
Wenn das unveränderte Nachbauen des Beispiels nicht funktioniert, liegt das daran, dass die Anleitung nicht narrensicher genug ist, oder dass sie Fehler enthält. Oder etwas ähnliches, was man zumindest als "nicht narrensicher genug" interpretieren kann.

Dein Link zu https://www.clickoslo.com/arduino-solar-tracker.html bietet allerdings beides.
Schönen Gruß an geobruce für sein Musterbeispiel dafür, dass das Internet sehr interessant aber auch großer Mist ist. (xprobe.net gibt es übrigens nicht mehr.)

Grundregel:
Du kannst nur sinnvoll übernehmen, was du soweit verstehst,
dass du es selbst besser machen könntest
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Tommy56 on Sep 11, 2020, 02:01 pm
dass die Anleitung nicht narrensicher genug ist
Narrensicher geht generell nicht: Die Narren sind zu erfinderisch. ;)

Gruß Tommy
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 11, 2020, 03:07 pm
Habe jetzt die Fehler soweit raus!

Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo Horizontal; // Horizontale Servo
int Servohorizontal = 90; // Servohorizontal start Position

Servo Vertikal; // Vertikale Servo
int Servovertikal = 90; // Servovertikal start Position

// LDR Stiftverbindungen
// Name = analogpin;
int LDRol = 0; // LDR oben links
int LDRor = 1; // LDR oben rechts
int LDRul = 2; // LDR unten links
int LDRur = 3; // LDR unten rechts

void setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  Horizontal.attach (9);
  Vertikal.attach (10);
}

void loop ()
{
  int OL = analogRead (LDRol); // oben links
  int OR = analogRead (LDRor); // oben rechts
  int UL = analogRead (LDRul); // unten links
  int UR = analogRead (LDRur); // unten rechts

  int dtime = analogRead (4) / 20; // Lesen Potentiometer
  int tol = analogRead (5) / 4;

  int avt = (LDRol + LDRor) / 2; // Mittelwert oben
  int avd = (LDRul + LDRur) / 2; // Mittelwert unten
  int avl = (LDRol + LDRul) / 2; // Mittelwert links
  int avr = (LDRor + LDRur) / 2; // Mittelwert rechts

  int dvert = avt - avd; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = avl - avr; // Überprüfen der diffirence zwischen links und rechts

  if (-1 * tol > dvert || dvert > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht vertikalen Winkel verändern
  {
    if (avt > avd)
    {
      Servovertikal = ++ Servovertikal;
      if (Servovertikal > 180)
      {
        Servovertikal = 180;
      }
    }
    else if (avt < avd)
    {
      Servovertikal = --Servovertikal;
      if (Servovertikal < 0)
      {
        Servovertikal = 0;
      }
    }
    Vertikal.write (Servovertikal);
  }

  if (-1 * tol > dhoriz || dhoriz > tol) // Überprüfen, ob die diffirence im Toleranz, wenn nicht horizontalen Winkel verändern
  {
    if (avl > avr)
    {
      Servohorizontal = --Servohorizontal;
      if (Servohorizontal < 0)
      {
        Servohorizontal = 0;
      }
    }
    else if (avl < avr)
    {
      Servohorizontal = ++ Servohorizontal;
      if (Servohorizontal > 180)
      {
        Servohorizontal = 180;
      }
    }
    else if (avl == avr)
    {
      // gar nichts
    }
    Horizontal.write (Servohorizontal);
  }


  // Die 4 Helligkeitswerte zu Testzwecken an den PC übertragen
  Serial.println(LDRor); // LDR oben links
  Serial.print(" - ");
  Serial.println(LDRor); // LDR oben rechts
  Serial.print(" - ");
  Serial.println(LDRul); // LDR unten links
  Serial.print(" - ");
  Serial.println(LDRur); // LDR unten rechts

  delay (dtime);
}

Bekomme jetzt beim Hochladen diesen Fehler:
Code: [Select]
Arduino: 1.8.13 (Windows 10), Board: "Arduino Uno"

Der Sketch verwendet 3862 Bytes (11%) des Programmspeicherplatzes. Das Maximum sind 32256 Bytes.

Globale Variablen verwenden 240 Bytes (11%) des dynamischen Speichers, 1808 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x0a

avrdude: stk500_recv(): programmer is not responding

Problem beim Hochladen auf das Board. Hilfestellung dazu unter http://www.arduino.cc/en/Guide/Troubleshooting#upload.

avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x0a



Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.


Was ist das Falsch? Muss das Programm über USB am Arduino oder über einen USBasp Adapter hochgeladen werden?
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: michael_x on Sep 11, 2020, 04:27 pm
Quote
Muss das Programm über USB am Arduino oder über einen USBasp Adapter hochgeladen werden?
Wie du willst.
Normalerweise geschieht "Hochladen" direkt über USB. Musst du das passende Board (ein Nano mit altem Bootloader ist kein Uno) und COM-Schnittstelle gewählt haben, und da darf kein anderes Programm (SerialMonitor) gleichzeitig aktiv sein.

Wenn du einen USBasp o.ä. verwenden willst, benutzt du "Hochladen mit Programmer" und überschreibst den Bootloader auf deinem Arduino.
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 11, 2020, 05:18 pm
Da ich diesen Arduino mal geflasht habe mit einem andern Programm, also auch den Bootloader muss ich es mit dem USBasp machen!

Der USBasp wird wie im Bild richtig erkannt, nur kommt beim Arduino Programm der Fehler:
Code: [Select]
Arduino: 1.8.13 (Windows 10), Board: "Arduino Uno"

Der Sketch verwendet 3862 Bytes (11%) des Programmspeicherplatzes. Das Maximum sind 32256 Bytes.

Globale Variablen verwenden 240 Bytes (11%) des dynamischen Speichers, 1808 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.

avrdude: Warning: cannot query manufacturer for device: No such file or directory

avrdude: Warning: cannot query product for device: No such file or directory

avrdude: Warning: cannot open USB device: Function not implemented

avrdude: error: could not find USB device with vid=0x16c0 pid=0x5dc vendor='www.fischl.de' product='USBasp'

avrdude: error: could not find USB device with vid=0x16c0 pid=0x5dc vendor='www.fischl.de' product='USBasp'





Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.

Sind die Treiber falsch?

PS.: HAt sich erledfigt, Treiber musste per "Zadig" für den Programmer installiert werden, danach geht es jetzt
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 20, 2020, 03:15 pm
Programm übertragen geht jetzt!

Ich habe am Programm noch etwas weiter gemacht...

Ist die Ausgabe für den aktuellen Servowinkel so richtig?
Serial.print(Servovertikal); // Servovertikal
Serial.print(Servohorizontal); //Servohorizontal

Würde auch gerne noch im Programm drin haben, wenn LDRol+LDRor+LDRul+LDRur zusammen unter z.B. 200 sind, soll er automatisch in die Startposition fahren und wenn der Wert z.B. 300 ist soll er anfangen die Winkel usw anzupassen. Wie müssten die Zeilen lauten?
Habe jetzt schonmal die Rechnung drin:
Code: [Select]
int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

if (LDRcheck < 200) ???servo in Startposition???

if (LDRcheck > 300) ???Programm ablauf soll gestartet werden???
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: michael_x on Sep 21, 2020, 11:56 am
Quote
Ist die Ausgabe für den aktuellen Servowinkel so richtig?
Serial.print(Servovertikal); // Servovertikal
Serial.print(Servohorizontal); //Servohorizontal
Das Problem ist, dass du die beiden Zahlen schwer auseinanderhalten kannst, weil sie in eine Zeile direkt hintereinander geschrieben werden.
Ein bisschen Fleiß und die Ausgabe ist besser lesbar:
Code: [Select]
Serial.print (" Servo V:"); Serial.print(Servovertikal);
Serial.print (" H:");Serial.println(Servohorizontal);


Die Frage, wie oft diese Ausgabe gemacht werden soll, willst du vermutlich mit dem Poti, über
delay(dtime); einstellen? 
Da wäre mir dein
int dtime = analogRead (4) / 20;
etwas hektisch :)


Quote
if (LDRcheck > 300) ???Programm ablauf soll gestartet werden???
Ja, warum nicht? Die geschweiften Klammern umfassen da einen relativ großen Bereich, aber mit richtigem Einrücken, oder dem Auslagern in separate Funktionen, erzeugt man Übersichtlichkeit.
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 22, 2020, 07:57 am
Danke für den Hinweis für die Ausgabe, habe es geändert!

Die delay(DTIME) habe ich bereits raus genommen, soll durch einen festen Wert angepasst werden!

Habe mal den einen Part reingeschrieben, das die Servos bei einem Wert unter 200 auf Startposition fahren und das Programm ab einen Wert von 300 startet.
Ist das so richtig?
Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo Horizontal; // Horizontale Servo
int Servohorizontal = 15; // Servohorizontal start Position

Servo Vertikal; // Vertikale Servo
int Servovertikal = 15; // Servovertikal start Position

// LDR Stiftverbindungen
// Name = analogpin;
int LDRol = 0; // LDR oben links
int LDRor = 1; // LDR oben rechts
int LDRul = 2; // LDR unten links
int LDRur = 3; // LDR unten rechts

void setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  Horizontal.attach (5);
  Vertikal.attach (6);
}

void loop ()
{
  int OL = analogRead (LDRol) * 1.0; // oben links, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int OR = analogRead (LDRor) * 1.0; // oben rechts, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int UL = analogRead (LDRul) * 1.0; // unten links, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int UR = analogRead (LDRur) * 1.0; // unten rechts, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int TOL = 200; // Wert, ab wann die Position geändert werden soll (Toleranz)

  int MWT = (LDRol + LDRor) / 2; // Mittelwert oben
  int MWU = (LDRul + LDRur) / 2; // Mittelwert unten
  int MWL = (LDRol + LDRul) / 2; // Mittelwert links
  int MWR = (LDRor + LDRur) / 2; // Mittelwert rechts

  int dvert = MWT - MWU; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = MWL - MWR; // Überprüfen der diffirence zwischen links und rechts
  int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

  if (LDRcheck < 200)
  {
    Horizontal.write (15);
    Vertikal.write (15);
  }

  if (LDRcheck > 300)
  {
    if (-1 * TOL > dvert || dvert > TOL) // Überprüfen, ob die diffirenz in der Toleranz liegt, wenn nicht vertikalen Winkel verändern
    {
      if (MWT > MWU)
      {
        Servovertikal = ++ Servovertikal;
        if (Servovertikal > 90)
        {
          Servovertikal = 90;
        }
      }
      else if (MWT < MWU)
      {
        Servovertikal = --Servovertikal;
        if (Servovertikal < 0)
        {
          Servovertikal = 0;
        }
      }
      Vertikal.write (Servovertikal);
    }

    delay (200); //Warten bis der Servovertikal in Position ist

    if (-1 * TOL > dhoriz || dhoriz > TOL) // Überprüfen, ob die diffirenz in der Toleranz liegt, wenn nicht horizontalen Winkel verändern
    {
      if (MWL > MWR)
      {
        Servohorizontal = --Servohorizontal;
        if (Servohorizontal < 0)
        {
          Servohorizontal = 0;
        }
      }
      else if (MWL < MWR)
      {
        Servohorizontal = ++ Servohorizontal;
        if (Servohorizontal > 180)
        {
          Servohorizontal = 180;
        }
      }
      else if (MWL == MWR)
      {
        // gar nichts
      }
      Horizontal.write (Servohorizontal);
    }
  }

  // Die 4 Helligkeitswerte und die Grad Zahl Servomotoren zu Testzwecken an den PC übertragen
  Serial.print (" LDRol:"); Serial.println(LDRol); // LDR oben links
  Serial.print(" - ");
  Serial.print (" LDRor:"); Serial.println(LDRor); // LDR oben rechts
  Serial.print(" - ");
  Serial.print (" LDRul:"); Serial.println(LDRul); // LDR unten links
  Serial.print(" - ");
  Serial.print (" LDRur:"); Serial.println(LDRur); // LDR unten rechts
  Serial.print(" - ");
  Serial.print (" Servo V:"); Serial.print(Servovertikal); // Servo Winkel Vertikal
  Serial.print(" - ");
  Serial.print (" Servo H:"); Serial.println(Servohorizontal); //Servo Winkel Horizontal

  delay (200);
}
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: agmue on Sep 22, 2020, 09:07 am
Nicht entscheidend, aber möglich:

Code: [Select]
  if (LDRcheck < 200)
  {
    Horizontal.write (15);
    Vertikal.write (15);
  }
  else if (LDRcheck > 300)
  {
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 22, 2020, 09:32 am
Meinst du mit "Nicht entscheidend, aber möglich", das man es nicht umbeding programmieren muss? Oder meinst du die Änderung von "if (LDRcheck > 300)" zu "else if (LDRcheck > 300)"?

Wäre es auch möglich bei den Winkel auf die Startwinkel am Anfang der Programmes zurück zugreifen?
Meine diese Zeilen:
Code: [Select]
Servo Horizontal; // Horizontale Servo
int Servohorizontal = 15; // Servohorizontal start Position

Servo Vertikal; // Vertikale Servo
int Servovertikal = 15; // Servovertikal start Position


Wenn ja, wie muss es dann statt "Horizontal.write (15)" & "Vertikal.write (15)" lauten?
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: agmue on Sep 22, 2020, 09:46 am
Diese Zeile scheint falsch:

Code: [Select]
 int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

Du addierst die Pinnummern.

Ungetesteter Versuch:

Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo Horizontal; // Horizontale Servo
const byte servoPinH = 5;
int Servohorizontal = 15; // Servohorizontal start Position

Servo Vertikal; // Vertikale Servo
const byte servoPinV = 6;
int Servovertikal = 15; // Servovertikal start Position

// LDR Stiftverbindungen
// Name = analogpin;
const byte LDRol = A0; // LDR oben links
const byte LDRor = A1; // LDR oben rechts
const byte LDRul = A2; // LDR unten links
const byte LDRur = A3; // LDR unten rechts

void setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  Horizontal.attach (servoPinH);
  Vertikal.attach (servoPinV);
}

void loop ()
{
  int OL = analogRead (LDRol) * 1.0; // oben links, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int OR = analogRead (LDRor) * 1.0; // oben rechts, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int UL = analogRead (LDRul) * 1.0; // unten links, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int UR = analogRead (LDRur) * 1.0; // unten rechts, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int TOL = 200; // Wert, ab wann die Position geändert werden soll (Toleranz)

  int MWT = (OL + OR) / 2; // Mittelwert oben
  int MWU = (UL + UR) / 2; // Mittelwert unten
  int MWL = (OL + UL) / 2; // Mittelwert links
  int MWR = (OR + UR) / 2; // Mittelwert rechts

  int dvert = MWT - MWU; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = MWL - MWR; // Überprüfen der diffirence zwischen links und rechts
  int LDRcheck = (OL + OR + UL + UR); // Gesamtwert der 4 LDR

  if (LDRcheck < 200)
  {
    Servohorizontal = 15;
    Horizontal.write (Servohorizontal);
    Servovertikal = 15;
    Vertikal.write (Servovertikal);
  }
  else if (LDRcheck > 300)
  {
    if (-1 * TOL > dvert || dvert > TOL) // Überprüfen, ob die diffirenz in der Toleranz liegt, wenn nicht vertikalen Winkel verändern
    {
      if (MWT > MWU)
      {
        Servovertikal++;
        if (Servovertikal > 90)
        {
          Servovertikal = 90;
        }
      }
      else if (MWT < MWU)
      {
        Servovertikal--;
        if (Servovertikal < 0)
        {
          Servovertikal = 0;
        }
      }
      Vertikal.write (Servovertikal);
    }

    delay (200); //Warten bis der Servovertikal in Position ist

    if (-1 * TOL > dhoriz || dhoriz > TOL) // Überprüfen, ob die diffirenz in der Toleranz liegt, wenn nicht horizontalen Winkel verändern
    {
      if (MWL > MWR)
      {
        Servohorizontal--;
        if (Servohorizontal < 0)
        {
          Servohorizontal = 0;
        }
      }
      else if (MWL < MWR)
      {
        Servohorizontal++;
        if (Servohorizontal > 180)
        {
          Servohorizontal = 180;
        }
      }
      else if (MWL == MWR)
      {
        // gar nichts
      }
      Horizontal.write (Servohorizontal);
    }
  }

  // Die 4 Helligkeitswerte und die Grad Zahl Servomotoren zu Testzwecken an den PC übertragen
  Serial.print (" LDRol:"); Serial.println(LDRol); // LDR oben links
  Serial.print(" - ");
  Serial.print (" LDRor:"); Serial.println(LDRor); // LDR oben rechts
  Serial.print(" - ");
  Serial.print (" LDRul:"); Serial.println(LDRul); // LDR unten links
  Serial.print(" - ");
  Serial.print (" LDRur:"); Serial.println(LDRur); // LDR unten rechts
  Serial.print(" - ");
  Serial.print (" Servo V:"); Serial.print(Servovertikal); // Servo Winkel Vertikal
  Serial.print(" - ");
  Serial.print (" Servo H:"); Serial.println(Servohorizontal); //Servo Winkel Horizontal

  delay (200);
}


EDIT: Entsprechend #27 zurück zu int geändert, sonst gibt es Warnungen. Danke!

Title: Re: Sonnen Verfolgung 2 Achsen
Post by: michael_x on Sep 22, 2020, 01:27 pm
unt16_t  -> uint16_t
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Sep 24, 2020, 09:51 am
Diese Zeile scheint falsch:

Code: [Select]
 int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

Haste recht habe es geändert, auch mit der Ausgabe funktioniert es!

unt16_t  -> uint16_t
Was meinst du damit?

Hier mein geändertes aktuelles Programm:
Code: [Select]
#include <Servo.h> // Servo-Library einbinden

Servo Horizontal; // Horizontale Servo
const byte servoPinH = 5;
int Servohorizontal = 15; // Servohorizontal start Position

Servo Vertikal; // Vertikale Servo
const byte servoPinV = 6;
int Servovertikal = 15; // Servovertikal start Position

// LDR Stiftverbindungen, Name = analogpin;
const byte LDRol = 0; // LDR oben links
const byte LDRor = 1; // LDR oben rechts
const byte LDRul = 2; // LDR unten links
const byte LDRur = 3; // LDR unten rechts

void setup ()
{
  Serial.begin (9600);
  // Servoanschlüsse
  // Name.attacht (Pin);
  Horizontal.attach (5);
  Vertikal.attach (6);
}

void loop ()
{
  int OL = analogRead (0) * 1.0; // oben links, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int OR = analogRead (1) * 1.0; // oben rechts, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int UL = analogRead (2) * 1.0; // unten links, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int UR = analogRead (3) * 1.0; // unten rechts, Faktor 1.0 anpassen, wenn die Widerstände sehr unterschiedlich sind
  int TOL = 100; // Wert, ab wann die Position geändert werden soll (Toleranz)

  int MWT = (OL + OR) / 2; // Mittelwert oben
  int MWU = (UL + UR) / 2; // Mittelwert unten
  int MWL = (OL + UL) / 2; // Mittelwert links
  int MWR = (OR + UR) / 2; // Mittelwert rechts

  int dvert = MWT - MWU; // Überprüfen der diffirence zwischen oben und unten
  int dhoriz = MWL - MWR; // Überprüfen der diffirence zwischen links und rechts
  int LDRcheck = (OL + OR + UL + UR); // Gesamtwert der 4 LDR

  if (LDRcheck < 200) // Wenn der Wert unter 200 ist, fahren die Servomotoren in die Startposition
  {
    Horizontal.write (15);
    Vertikal.write (15);
  }

  else if (LDRcheck > 300) // Wenn der Wert über 300 ist, startet die Ausrichtung
  {
    if (-1 * TOL > dvert || dvert > TOL) // Überprüfen, ob die diffirenz in der Toleranz liegt, wenn nicht vertikalen Winkel verändern
    {
      if (MWT > MWU)
      {
        Servovertikal = ++ Servovertikal;
        if (Servovertikal > 90)
        {
          Servovertikal = 90; // Maximaler Winkelwert
        }
      }
      else if (MWT < MWU)
      {
        Servovertikal = --Servovertikal;
        if (Servovertikal < 0)
        {
          Servovertikal = 0; // Minimaler Winkelwert
        }
      }
      Vertikal.write (Servovertikal);
    }

    delay (200); //Warten bis der Servovertikal in Position ist

    if (-1 * TOL > dhoriz || dhoriz > TOL) // Überprüfen, ob die diffirenz in der Toleranz liegt, wenn nicht horizontalen Winkel verändern
    {
      if (MWL > MWR)
      {
        Servohorizontal = --Servohorizontal;
        if (Servohorizontal < 0)
        {
          Servohorizontal = 0; // Minimaler Winkelwert
        }
      }
      else if (MWL < MWR)
      {
        Servohorizontal = ++ Servohorizontal;
        if (Servohorizontal > 180)
        {
          Servohorizontal = 180; // Maximaler Winkelwert
        }
      }
      else if (MWL == MWR)
      {
        // gar nichts
      }
      Horizontal.write (Servohorizontal);
    }
  }

  // Die 4 Helligkeitswerte und die Grad Zahl Servomotoren zu Testzwecken an den PC übertragen
  Serial.print ("LDRol:"); Serial.print(OL); // LDR oben links
  Serial.print (" LDRor:"); Serial.println(OR); // LDR oben rechts
  Serial.print ("LDRul:"); Serial.print(UL); // LDR unten links
  Serial.print (" LDRur:"); Serial.println(UR); // LDR unten rechts
  Serial.print ("Servo V:"); Serial.print(Servovertikal); // Servo Winkel Vertikal
  Serial.print (" Servo H:"); Serial.println(Servohorizontal); //Servo Winkel Horizontal

  delay (1000);
}


Was jetzt noch schön wäre, wenn man hier auf den Startwinkel oben verweißen könnte:
Code: [Select]
if (LDRcheck < 200) // Wenn der Wert unter 200 ist, fahren die Servomotoren in die Startposition
  {
    Horizontal.write (15);
    Vertikal.write (15);
  }


Sind die Bezeichungen die ich soweit dahinter geschrieben habe soweit richtig?

(https://forum.arduino.cc/index.php?action=dlattach;topic=704392.0;attach=382981)
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: agmue on Sep 24, 2020, 11:27 am
Was jetzt noch schön wäre, wenn man hier auf den Startwinkel oben verweißen könnte:
Guckst Du bitte #26.

Title: Re: Sonnen Verfolgung 2 Achsen
Post by: michael_x on Sep 25, 2020, 11:47 am
Quote
[uint16_t] Was meinst du damit?
Ein Tippfehler in agmue's Beitrag. Schon dort korrigiert.
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Nov 02, 2020, 02:29 pm
Da bei meinem vorhaben die Motoren leider zu schwach sind, möchte ich euch mal zum Rat bitten.
Die PV Platten sind je 1700x1000mm diese werden nebeneinander auf dem Gestellt montiert. Jetzt ist nur die Frage was für Motoren nehme ich für die Neigung und für das Drehen?
Für die Neigung habe ich an sowas gedacht:
Code: [Select]
https://www.ebay.de/itm/1500N-Linear-Actuator-12V-Linearantrieb-Linearmotor-Verstellantrieb-Turoffner-DE/401750711570?_trkparms=ispr%3D1&hash=item5d8a355d12:g:fFEAAOSwi9VfnSwl&amdata=enc%3AAQAFAAACcBaobrjLl8XobRIiIML1V4Imu%252Fn%252BzU5L90Z278x5ickkTboA95HSvGa1O5UmCCGJLhNkM6E0ClXMixtF7ZtJzjVt2fetTBnFt%252BpCaClnjuIwc1pxzKuuMPWtck%252B40pPAinNF42fgRp9az5jmS4o6%252BhU1C%252BdDNhJYihcmYWFXG3sS3a4p4kgzmVjWYzzweZVzBXbF9iIjEVLssR9oRIiwUKNlphtpvNwrOgJ91a%252B9vgoK78MCbufiEryZmDDDJM0j99Fq5rmODp7YYBADXeUB6SE9mJoG4A0u9%252BAL0MhEZUciMgsKtHUTBJ4TbyqjPYp8JnVUIPrB1TMKQJao6%252FQ8xfjnE%252FMhqBbjwGwb5GTV8WVJsM3LLdbXuKOS7SUDOm9if5wx2qJvCRtP%252BRS8NqbQtnY2ZUAwFnjU5sHEzOUCXvaqLiGeJrI852GfnOSO7s5pc8bwreDTIRhslvnzrw7P%252BCGYff%252BTBbE%252FKkGm8xjXauZCaCJ5vpPI9yPd2iJ5qCSgCYxIWD3A9XpiCCX5qJBSXHWH6FqAotdSXYCadX%252B1ytAynVRV%252FRDME1Npsk2BHi8Qz8nu0sYFvrlbNT%252BIei%252Bqou5JzQInhAb3PGfaNDJ0%252FcY%252BEYscGt76JvDJyuPugEUGfP91lzsev6v0Lvms9T5aTidvjnGS5ctuMzcdP5lMr%252F1LxeV%252BABT87wWQ2oKL84jQxhHg1KQKmE8GujJr5HrKG%252BzWzZkEeo3uM2neUZo5HzE%252F%252FUJZTBNGvAuJ6mkQgYEUP3V4Jd9Sv1JKZt%252FSej%252B8WAy5J7%252FxBpyWcL%252FlJwskkXyYgrZ5XrkBDKg0dEcgIhLpiA%253D%253D%7Ccksum%3A40175071157082f711aa87a34ad587f8a1819cfdddda%7Campid%3APL_CLK%7Cclp%3A2334524

Und zum drehen (180°) an sowas (ist der Wasserdicht, da ebenfalls draußen???):
Code: [Select]
https://www.amazon.de/Schrittmotor-geschlossener-Encoder-Feedback-Arduino-Welle-CNC-Lasermaschine/dp/B07ZKCHP3V/ref=sr_1_174?_encoding=UTF8&c=ts&dchild=1&keywords=3D-Drucker-Motoren&qid=1604341081&s=industrial&sr=1-174&ts_id=6589294031
Wäre das so richtig und auch per Arduino ansteuerbar oder habt ihr andere Vorschläge?
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Peter-CAD-HST on Nov 02, 2020, 02:52 pm
Moin newpv
Schaue dir nochmal die Formulierung der Links an, die funktionieren nicht.
Gruss Peter
und gesund bleiben
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Nov 02, 2020, 07:15 pm
Danke für den Hinweis,. habe die Links korrigiert!
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: newpv on Nov 05, 2020, 07:50 am
Moin newpv

Mal ne schnelle Frage:
Warum nimmst du keine lokale Uhr um den Sonnenstand zu verfolgen?
Da ich erstmal etwas mit dem Arduino lernen wollte habe ich es erstmal über die LDRs gemacht, das geht jetzt auch soweit, jetzt kann ich einen Schritt weiter gehen und es über den Sonnenstand machen...natürlich mit eurer Hilfe!
Meinst du sowas in der Art:
http://mi-schu.de/solartracker.htm
Title: Re: Sonnen Verfolgung 2 Achsen
Post by: Peter-CAD-HST on Nov 05, 2020, 08:25 am
Moin newpv
Ja, das ist ein Solartracker, der unabhängig von Wettereinflüssen und von spontanen Entladungen von geflügelten Fluggeräten auf den LDR-Sonnensensor unabhängig arbeitet.  :)
Gruß Peter
und gesund bleiben