Sonnen Verfolgung 2 Achsen

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:

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

Unbenannt.JPG

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:

int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

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

if (LDRcheck > 300) ???Programm ablauf soll gestartet werden???

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:

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 :)

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.

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?

#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);
}

Nicht entscheidend, aber möglich:

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

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:

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?

Diese Zeile scheint falsch:

  int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

Du addierst die Pinnummern.

Ungetesteter Versuch:

#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!

unt16_t → uint16_t

agmue:
Diese Zeile scheint falsch:

  int LDRcheck = (LDRol + LDRor + LDRul + LDRur); // Gesamtwert der 4 LDR

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

michael_x:
unt16_t → uint16_t

Was meinst du damit?

Hier mein geändertes aktuelles Programm:

#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:

 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?

Ausgabe.JPG

newpv: Was jetzt noch schön wäre, wenn man hier auf den Startwinkel oben verweißen könnte:

Guckst Du bitte #26.

[uint16_t] Was meinst du damit?

Ein Tippfehler in agmue's Beitrag. Schon dort korrigiert.

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:

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???):

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?

(deleted)

Danke für den Hinweis,. habe die Links korrigiert!

Peter-CAD-HST: 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

(deleted)

Hallo,
ich habe jetzt meine weitere Hardware erhalten, Endschalter, Relais, usw.
Die Endschalter habe ich wie die LDRs in einer eigenen Schaltung mit Widerstand angeschlossen und dann an den Digital Pin 0 und 1. Aber ich bekomme keine Änderung des Status über die Serielle Schnittstelle. Liegt es an den verwendeten Pinen? Oder habe ich etwas falsch im String:

// Sonnen Verfolgung v2 vom 17.11.2020

int Endschalter1pin = 0; // Vertikal Endschalter oben
int Endschalter1Status; // Zustand des Endschalter oben merken
int Endschalter2pin = 1; // Vertikal Endschalter unten
int Endschalter2Status; // Zustand des Endschalter unten merken

int Relais1pin = 2; // Relais 1 für Vertikale Achse, hoch fahren
int Relais2pin = 3; // Relais 2 für Vertikale Achse, runter fahren

// 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 ()
{
  pinMode(Endschalter1pin, INPUT); //Pin Modus definieren, Eingang
  pinMode(Endschalter2pin, INPUT); //Pin Modus definieren, Eingang

  pinMode(Relais1pin, OUTPUT); //Pin Modus definieren, Ausgang
  pinMode(Relais2pin, OUTPUT); //Pin Modus definieren, Ausgang

  Serial.begin(9600); // Serielle Schnittstelle initialisieren
}

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, fahrt der Linearmotor und der Servomotoren in die Startposition
  {
    digitalWrite(Relais1pin, HIGH); //Vertikalachse in die unterste Stellung
    digitalWrite(Relais2pin, LOW); //Vertikalachse in die unterste Stellung
    Endschalter2Status = digitalRead(Endschalter2pin);
    if (Endschalter2Status = HIGH); // Wenn der untere Endschalter erreicht wurde, sollen die Relais deaktiviert werden
    {
      digitalWrite(Relais1pin, LOW);
      digitalWrite(Relais2pin, LOW);
    }
  }

  else if (LDRcheck > 350) // Wenn der Wert über 350 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) // LDR oben heller wie unten, runter fahren
      {
        Endschalter1Status = digitalRead(Endschalter1pin);
        if (Endschalter1pin = HIGH); // Wenn der untere Endschalter erreicht wurde, soll nichts passieren
        {
          digitalWrite(Relais1pin, LOW);
          digitalWrite(Relais2pin, LOW);
        }
      }
      else if (Endschalter2pin = LOW); // Wenn der untere Endschalter erreicht nicht wurde, soll er fahren
    {
      digitalWrite(Relais1pin, LOW);
      digitalWrite(Relais2pin, HIGH);
    }
    if (dvert < 10) // Wenn der Vertikale Wert
    {
      digitalWrite(Relais2pin, LOW);
      digitalWrite(Relais2pin, LOW);
    }

    else if (MWT < MWU) // LDR unten heller wie oben
    {
      Endschalter1pin = digitalRead(Endschalter1pin);
      if (Endschalter1pin = HIGH); // Wenn der obere Endschalter erreicht wurde, soll nichts passieren
      {
        digitalWrite(Relais1pin, LOW);
        digitalWrite(Relais2pin, LOW);
      }
    }
    else if (Endschalter1pin = HIGH); // Wenn der untere Endschalter erreicht wurde, soll er fahren
    {
      digitalWrite(Relais1pin, HIGH);
      digitalWrite(Relais2pin, LOW);
    }
    if (dvert < 10) // Wenn der Vertikale Wert
    {
      digitalWrite(Relais2pin, LOW);
      digitalWrite(Relais2pin, LOW);
    }
  }
  // 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 ("Endschalter oben:"); Serial.print(Endschalter1Status); // Endschalter Vertikal oben
  Serial.print ("Endschalter unten:"); Serial.println (Endschalter2Status); // Endschalter Vertikal unten
  Serial.print ("LDR Gesamt:"); Serial.println(LDRcheck); //LDR Gesamtwert
  delay(10000);
}

PS: Falls ihr noch andere Fehler entdecken solltet bitte ich um jeden Hinweis!

Falls Du einen UNO/Nano/MEGA verwendest, hast Du Dir mit Deinen Anschlüssen an Pin 0/1 wohl die Serielle Verbindung gestört. Die sollten nicht für etwas Anderes, als die USB-Verbindung, benutzt werden.

Gruß Tommy

Danke für deine Antwort also kann man die Digitalenanschlüsse von 2-13 nutzen. Habe bereits geändert! Hast du sonst noch Fehler entdeckt?

Beim Uno/Nano kannst du auch die Analogen A0.. (auch unter der Nummer 14 .. 19) mit digitalRead / digitalWrite benutzen.