Sonnen Tracker Arduino

So jetzt ist die Hardware da :grinning:!
Der Sketch für den Windmesser sieht so aus:

const int Messzeit = 3; //Definiere Messzeit in Sekunden
const int Windmesser = 3;  //Definiere Eingangs Pin

int Unterbrechungszaehler;
float Windgeschwindigkeit;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  static unsigned long lastprint;
  if (millis() - lastprint > 3000) // Testausgabe alle 3s
  {
    Windmessung();
    Serial.print("Windgeschwindigkeit: ");
    Serial.print(Windgeschwindigkeit);       //Windgeschwindigkeit in Km/h
    Serial.print(" km/h");
  }
}

void Windmessung()
{
  Unterbrechungszaehler = 0;
  attachInterrupt(digitalPinToInterrupt(Windmesser), Unterbrechung, RISING);
  delay(1000 * Messzeit);
  detachInterrupt(digitalPinToInterrupt(Windmesser));
  Windgeschwindigkeit = (float)Unterbrechungszaehler / (float)Messzeit * 2.4;
}

void Unterbrechung()
{
  Unterbrechungszaehler++;
}

Ist er richtig so, oder sollte man da was ändern? Wenn ich den Windmesser drehe wird mir die Geschwindigkeit angezeigt!

Jetzt möchte ich, wenn die Geschwindigkeit über z.B. 35Km/h (wird angepasst wenn alles läuft und Wind kommt wie es sich verhält...) diese Sketch unterbrochen wird:

  // Vertikalachse ausrichten, Linearmotor 3000N 200mm
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DVERT > TOLV) && (GWO < GWU) && ((Endschalter2VEHSStatus == LOW) || (Endschalter2VEOOEStatus == HIGH))) // // je LDR über "START" Wert, "DVERT" größer "TOLV" Wert, oben heller wie unten, Endschalter 2 schließer und öffner nicht betätigt
  {
    digitalWrite(Relais1pin, HIGH); // Zylinder ausfahren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DVERT > TOLV) && (GWO > GWU) && (Endschalter1VEVSStatus == LOW)) // je LDR über "START" Wert, "DVERT" größer "TOLV" Wert, oben dunkler wie unten, Endschalter 1 schließer nicht betätigt ist
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, HIGH); // Zylinder einfahren
  }


  // Vertikalachse ausrichten abgeschlossen und die Relais 1 und 2 deaktivieren
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DVERT <= ENDEV)) // LDR gesamt über "START" Wert, oben und unten gleich hell sind oder eine max. Differnz von "ENDEV" haben
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && ((Endschalter2VEHSStatus == HIGH) || (Endschalter2VEOOEStatus == LOW)) && (digitalRead(Relais1pin) == HIGH) && (digitalRead(Relais2pin) == LOW)) // je LDR über "START" Wert, Endschalter 2 schließer und öffner betätigt, Relais 1 betätigt und Relais 2 aus
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (Endschalter1VEVSStatus == HIGH) && (digitalRead(Relais1pin) == LOW) && (digitalRead(Relais2pin) == HIGH)) // je LDR über "START" Wert, Endschalter 1 schließer betätigt, Relais 1 aus und Relais 2 betätigt ist
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }

Jetzt könnte man ja z.B. rein machen

If Windgeschwindigkeit < 35...soll er den Sketch ausführen

If ((Windgeschwindigkeit > 35)  && (Endschalter1VEVSStatus == LOW))
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, HIGH); // Zylinder einfahren
  }

If ((Windgeschwindigkeit > 35)  && (Endschalter1VEVSStatus == HIGH))
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }

Das Problem ist ja nur, wenn jetzt eine Böhe kommt, würde er die Achse kurz einfahren und dann evtl. wieder ausfahren, wie kann man das Verhindern?

Kann man das evtl. mit Mills machen? Hatte mir Mal gedacht, das er wenn eine Windgeschwindigkeit von 35km/h erreicht wurde er die Achsen runter fährt und dann z.B. 10min wartet und die 10Min immer wieder "erneuert" werden wenn wieder eine Böe von 35km/h kommt

Willst du denn im Windkanal ausprobieren wie lange eine Böe wie stark sein darf so dass du dann
innerhalb von 2 Minuten in eine "ungefährliche Position zu fahren dein Gestell von der plötzlich ansteigende Böe doch schon verbogen ist?

professionelle Solarnachführungen sind so stabil gebaut dass sie nur bei extremem Sturm
in eine waagerechte Position fahren.

"Sketch" ist das ganze Programm. von der ersten bis zur letzten Zeile
Man kann also nicht von "diese Sketch unterbrochen wird:" sprechen.

Eine von mehreren Arten sauber und sorgfältig zu programmieren ist:

Eine function macht eine Sache.
Beispiele:

  • Achse in die waagerechte Position fahren
  • Windgeschwindigkeit messen
  • Werte der Lichtsensoren erfassen und auf Gleichheit prüfen Differenz berechnen
  • Achse nachführen

Wenn man sein Programm so strukturiert hat ist es wesentlich einfacher Bedingungen zu programmieren.

vgs

Nein, ich möchte bei einer Boe in waagerechte fahren...bis es wieder vorbei ist!
Deshlab auch meine Frage, wenn eine Boe gekommen ist in waagerechte fahren und dann soll eine Zeit laufen, z.B. wenn dann wieder eine Boe kommt soll die Zeit wieder vom neuen beginnen. Ich suche nur nach ideen wie man es umsetzen kann.

Der akteulle Sketch ohne WIndgeschwindigkeit sieht so aus:

// Sonnen Verfolgung Vertikal und Horizontal v9.0 vom 14.06.2021

const int Endschalter1VEVS = 2; // Vertikal Endschalter vorne, schließer
const int Endschalter2VEHS = 3; // Vertikal Endschalter hinten, schließer
const int Endschalter2VEOOE = 4; // Vertikal Endschalter hinten, öffner

const int Relais1pin = 5; // Relais 1 für Vertikale Achse, Zylinder ausfahren
const int Relais2pin = 6; // Relais 2 für Vertikale Achse, Zylinder einfahren

const int Endschalter3HEVS = 7; // Horizontal Endschalter vorne, schließer
const int Endschalter4HEHS = 8; // Horizontal Endschalter hinten, schließer
const int Endschalter4HEHOE = 9; // Horizontal Endschalter hinten, öffner

const int Relais3pin = 10; // Relais 3 für Horizontal Achse, Zylinder ausfahren
const int Relais4pin = 11; // Relais 4 für Horizontal Achse, Zylinder einfahren

// LDR Stiftverbindungen am Analogpin, LDR5528, GL5528, 0,5-200kOhm, 5mm
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

// Feste Werte
int START = 300; // Wert ab wann das Programm wieder Startet (jeder Einzelner LDR)
int TOLV = 170; // Wert, ab wann die Position Veretikal geändert werden soll (Toleranz)
int TOLH = 170; // Wert, ab wann die Position Horizontal geändert werden soll (Toleranz)
int ENDEV = 10; // Wert zum Beenden der Ausrichtung Vertikal
int ENDEH = 10; // Wert zum Beenden der Ausrichtung Horizontal
int NACHT = 55; // Wert ab wann die Linearmotoren in Startposition fahren (Progamm bei Dunkelheit beendet, jeder Einzelner LDR)

void setup ()
{
  pinMode(Endschalter1VEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEOOE, INPUT); // Pin Modus definieren, Eingang, öffner

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

  pinMode(Endschalter3HEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHOE, INPUT); // Pin Modus definieren, Eingang, öffner

  pinMode(Relais3pin, OUTPUT); // Pin Modus definieren, Ausgang
  pinMode(Relais4pin, 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 GWO = (OL + OR); // Gesamtwert oben
  int GWU = (UL + UR); // Gesamtwert unten
  int GWL = (OL + UL); // Gesamtwert links
  int GWR = (OR + UR); // Gesamtwert rechts

  int DVERT = abs(GWO - GWU); // Überprüfen der Diffirenz zwischen oben und unten, Vertikal, immer Positiv setzen
  int DHORIZ = abs(GWL - GWR); // Überprüfen der Diffirenz zwischen links und rechts, Horizontal, immer Positiv setzen

  int Endschalter1VEVSStatus = digitalRead(Endschalter1VEVS); // Zustand des Endschalter Vertikal vorne, schließer
  int Endschalter2VEHSStatus = digitalRead(Endschalter2VEHS); // Zustand des Endschalter Vertikal hinten, schließer
  int Endschalter2VEOOEStatus = digitalRead(Endschalter2VEOOE); // Zustand des Endschalter Vertikal hinten, öffner
  int Endschalter3HEVSStatus = digitalRead(Endschalter3HEVS); // Zustand des Endschalter Horizontal vorne, schließer
  int Endschalter4HEHSStatus = digitalRead(Endschalter4HEHS); // Zustand des Endschalter Horizontal hinten, schließer
  int Endschalter4HEHOEStatus = digitalRead(Endschalter4HEHOE); // Zustand des Endschalter Horizontal hinten, öffner

  // Vertikalachse ausrichten, Linearmotor 3000N 200mm
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DVERT > TOLV) && (GWO < GWU) && ((Endschalter2VEHSStatus == LOW) || (Endschalter2VEOOEStatus == HIGH))) // // je LDR über "START" Wert, "DVERT" größer "TOLV" Wert, oben heller wie unten, Endschalter 2 schließer und öffner nicht betätigt
  {
    digitalWrite(Relais1pin, HIGH); // Zylinder ausfahren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DVERT > TOLV) && (GWO > GWU) && (Endschalter1VEVSStatus == LOW)) // je LDR über "START" Wert, "DVERT" größer "TOLV" Wert, oben dunkler wie unten, Endschalter 1 schließer nicht betätigt ist
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, HIGH); // Zylinder einfahren
  }


  // Vertikalachse ausrichten abgeschlossen und die Relais 1 und 2 deaktivieren
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DVERT <= ENDEV)) // LDR gesamt über "START" Wert, oben und unten gleich hell sind oder eine max. Differnz von "ENDEV" haben
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && ((Endschalter2VEHSStatus == HIGH) || (Endschalter2VEOOEStatus == LOW)) && (digitalRead(Relais1pin) == HIGH) && (digitalRead(Relais2pin) == LOW)) // je LDR über "START" Wert, Endschalter 2 schließer und öffner betätigt, Relais 1 betätigt und Relais 2 aus
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (Endschalter1VEVSStatus == HIGH) && (digitalRead(Relais1pin) == LOW) && (digitalRead(Relais2pin) == HIGH)) // je LDR über "START" Wert, Endschalter 1 schließer betätigt, Relais 1 aus und Relais 2 betätigt ist
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }


  // Horizontalachse ausrichten, Linearmotor 3000N 100mm
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DHORIZ > TOLH) && (GWL > GWR) && ((Endschalter4HEHSStatus == LOW) || (Endschalter4HEHOEStatus == HIGH))) // je LDR über "START" Wert, "DHORIZ" größer "TOLH" Wert, rechts heller wie links, Endschalter 4 schließer und öffner nicht betätigt
  {
    digitalWrite(Relais3pin, HIGH); // Zylinder ausfahren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DHORIZ > TOLH) && (GWL < GWR) && (Endschalter3HEVSStatus == LOW)) // je LDR über "START" Wert, "DHORIZ" größer "TOLH" Wert, rechts dunkler wie links, Endschalter 3 schließer nicht betätigt
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, HIGH); // Zylinder einfahren
  }


  // Horizontalachse ausrichten abgeschlossen und die Relais 3 und 4 deaktivieren
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (DHORIZ <= ENDEH)) // je LDR über "START" Wert, oben und unten gleich hell sind oder eine max. Differnz von "ENDEH" haben
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && ((Endschalter4HEHSStatus == HIGH) || (Endschalter4HEHOEStatus == LOW)) && (digitalRead(Relais3pin) == HIGH) && (digitalRead(Relais4pin) == LOW)) // je LDR über "START" Wert, Endschalter 4 schließer und öffner betätigt, Relais 3 betätigt und Relais 4 aus
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }
  else if ((OL > START) && (OR > START) && (UL > START) && (UR > START) && (Endschalter3HEVSStatus == HIGH) && (digitalRead(Relais3pin) == LOW) && (digitalRead(Relais4pin) == HIGH)) // je LDR über "START" Wert, Endschalter 3 schließer betätigt, Relais 3 aus und Relais 4 betätigt ist
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }


  // Grundstellung bei Dunkelheit, Wert "NACHT"
  if ((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT) && (Endschalter1VEVSStatus == LOW))// je LDR unter "ENDE" Wert und der Endschalter 1 schließer nicht betätigt, fährt die Vertikalachse in die Startposition
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, HIGH); // Zylinder einfahren, Vertikal
  }
  if ((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT) && (Endschalter1VEVSStatus == HIGH)) // je LDR unter "NACHT" Wert ist, der Endschalter 1 schließer betätigt
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  if ((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT) && (Endschalter3HEVSStatus == LOW))// je LDR unter "NACHT" Wert und der Endschalter 3 schließer nicht betätigt, fährt die Horizontalachse in die Startposition
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, HIGH); // Zylinder einfahren, Horizontal
  }
  if ((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT) && (Endschalter3HEVSStatus == HIGH)) // je LDR unter "NACHT" Wert ist, der Endschalter 3 schließer betätigt
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }

  // Die 4 Helligkeitswerte, Berechnung der Helligkeitswerte, Relais und die Endschalterzustände zu Testzwecken an den PC übertragen
  static unsigned long lastprint;
  if (millis() - lastprint > 3000) // Testausgabe alle 3s
  {
    lastprint = millis();
    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("GWO:"); Serial.print(GWO); // Gesamtwert oben
    Serial.print(" GWU:"); Serial.println(GWU); // Gesamtwert unten
    Serial.print("GWL:"); Serial.print(GWL); // Gesamtwert links
    Serial.print(" GWR:"); Serial.println(GWR); // Gesamtwert rechts
    Serial.print("Diff O & U:"); Serial.print(DVERT); // Diffirence zwischen oben und unten
    Serial.print(" Diff L & R:"); Serial.println(DHORIZ); // Diffirence zwischen links und rechts
    Serial.print("Relais 1:"); Serial.print(digitalRead(Relais1pin)); // Zustand Relais 1
    Serial.print(" Relais 2:"); Serial.println (digitalRead(Relais2pin)); // Zustand Relais 1
    Serial.print("Relais 3:"); Serial.print(digitalRead(Relais3pin)); // Zustand Relais 1
    Serial.print(" Relais 4:"); Serial.println (digitalRead(Relais4pin)); // Zustand Relais 1
    Serial.print("Endschalter1VEVS:");
    if (Endschalter1VEVSStatus == LOW) // Vertikal Endschalter vorne betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter1VEVSStatus == HIGH) // Vertikal Endschalter vorne nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
    Serial.print("Endschalter2VEHS:");
    if (Endschalter2VEHSStatus == LOW) // Vertikal Endschalter hinten betätigt kommt die Ausgabe 0
    {
      Serial.print("0");
    }
    else if (Endschalter2VEHSStatus == HIGH) // Vertikal Endschalter hinten nicht betätigt kommt die Ausgabe 1
    {
      Serial.print("1");
    }
    Serial.print(" Endschalter2VEOOE:");
    if (Endschalter2VEOOEStatus == LOW) // Vertikal Endschalter hinten betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter2VEOOEStatus == HIGH) // Vertikal Endschalter hinten nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
    Serial.print("Endschalter3HEVS:");
    if (Endschalter3HEVSStatus == LOW) // Vertikal Endschalter vorne betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter3HEVSStatus == HIGH) // Vertikal Endschalter vorne nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
    Serial.print("Endschalter4HEHS:");
    if (Endschalter4HEHSStatus == LOW) // Vertikal Endschalter hinten betätigt kommt die Ausgabe 0
    {
      Serial.print("0");
    }
    else if (Endschalter4HEHSStatus == HIGH) // Vertikal Endschalter hinten nicht betätigt kommt die Ausgabe 1
    {
      Serial.print("1");
    }
    Serial.print(" Endschalter4HEHOE:");
    if (Endschalter4HEHOEStatus == LOW) // Vertikal Endschalter oben betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter4HEHOEStatus == HIGH) // Vertikal Endschalter oben nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
  }
}

Was mir sofort auffällt ist:

delay(1000 * Messzeit);

Das blockiert und ist daher grundsätzlich böse!

PUH!
Nur das drüber schaun, macht mír Kopfzerbrechen.
Was hast Du da mit dem Code vor?
Wenn Du den mal erweitern willst, kommst in Teufels Küche.
Ach. willst ja schon. :wink:
Schau mal...
Was fällt Dir auf? (Ja ich hab das überflüssige abfragen der Bedingung absichtlich unkenntlich gemacht und nur das, was ich gesehen habe stehen gelassen....)


  // Vertikalachse ausrichten abgeschlossen und die Relais 1 und 2 deaktivieren
  ((OL > START) && (OR > START) && (UL > START) && (UR > START) 
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  ((OL > START) && (OR > START) && (UL > START) && (UR > START)
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }
  ((OL > START) && (OR > START) && (UL > START) && (UR > START)
  {
    digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
    digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
  }

  // Horizontalachse ausrichten, Linearmotor 3000N 100mm
  ((OL > START) && (OR > START) && (UL > START) && (UR > START)
  {
    digitalWrite(Relais3pin, HIGH); // Zylinder ausfahren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }
  ((OL > START) && (OR > START) && (UL > START) && (UR > START)
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, HIGH); // Zylinder einfahren
  }

  // Horizontalachse ausrichten abgeschlossen und die Relais 3 und 4 deaktivieren
  ((OL > START) && (OR > START) && (UL > START) && (UR > START)
  {
    digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
    digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
  }
 

Warum in aller Welts Namen machst Du sowas und fasst das nicht zusammen?
Dann wäre es auch möglich in Deinem Code ggfls den Rest der Bedingungen rechts von dem zu sehen....

1 Like

Du hast überhaupt nicht verstanden auf was ich hinaus will:

Wie lange dauert es bis du aus Position Nachmittagssonne auf Position waagerecht gefahren bist?
0,05 Sekunden? 0,1 Sekunden? oder vielleicht eher 20 Sekunden?

20 Sekunden lang eine starke Böe die mit 35 km/h anfängt und dann innerhalb von 5 Sekunden auf 80 km/h ansteigt ==> Gestell verbogen bevor es in waagerechter Position ist.

Daher meine Aussage:

vgs

Habe jetzt meinen Sketch etwas geändert...

const int Messzeit = 3; // Definiere Messzeit in Sekunden
const int Windmesser = 3;  // Definiere Eingangs Pin

int Unterbrechungszaehler; // Kontakt Unterbrechungen
float Windgeschwindigkeit; // aktuelle Windgeschwindigkeit
float Windboe; // Windboe
const int Windschutz = 35; // Wert ab wann bei Sturm eingefahren werden soll

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  if (Windgeschwindigkeit > Windschutz)
  {
    (Windboe = Windgeschwindigkeit);
  }

  static unsigned long lastprint;
  if (millis() - lastprint > 3000) // Testausgabe alle 3s
  {
    Serial.print("Windgeschwindigkeit: "); Serial.print(Windgeschwindigkeit); Serial.print(" km/h"); //Windgeschwindigkeit in Km/h
    Serial.print("Windboe: "); Serial.print(Windboe); Serial.print(" km/h"); //Windgeschwindigkeit in Km/h
  }
}

void Windmessung()
{
  Unterbrechungszaehler = 0;
  attachInterrupt(digitalPinToInterrupt(Windmesser), Unterbrechung, RISING);
  detachInterrupt(digitalPinToInterrupt(Windmesser));
  Windgeschwindigkeit = (float)Unterbrechungszaehler / (float)Messzeit * 2.4;
}

void Unterbrechung()
{
  Unterbrechungszaehler++;
}

Wie kann ich es anpassen, das mir die Werte der Seriellen Ausgabe "nur" alle 3 sek. Auszugeben wie im Sketch und der Rest nicht Ausgegeben wird...

Weil jetzt ratterterda so schnell durch das man nicht lesen kann :sunglasses:

Weil die Bedingung für den Rest, den du nicht mit drin hast ja anders sind...
Meinst du damit, das ist im void setup variabeln machen sollte und alles was gleich ist dort definieren soll?

millis()

Ne.
Einfach einmal abfragen und weiterverwenden.

Aber bevor wir da anfangen:
PINS nicht als int - nur als byte!
Auch wenn der Compiler das was schickes draus macht, gehe davon aus, das Du 2 Bytes verbrauchst, wo Du nur eines brauchst.

Dann schreibst Du al Kommentar:

// Feste Werte

und machst sowas draus:

int START = 300;

Da gehört dann ein const davor.

Hier:
int Endschalter1VEVSStatus = digitalRead(Endschalter1VEVS);
fragst nur einen Zustand ab. Das ist ein Bit und Du verbrauchst dafür zwei Byte.

So und nu zu dem Rest

// Sonnen Verfolgung Vertikal und Horizontal v9.0 vom 14.06.2021

const byte Endschalter1VEVS = 2; // Vertikal Endschalter vorne, schließer
const byte Endschalter2VEHS = 3; // Vertikal Endschalter hinten, schließer
const byte Endschalter2VEOOE = 4; // Vertikal Endschalter hinten, öffner

const byte Relais1pin = 5; // Relais 1 für Vertikale Achse, Zylinder ausfahren
const byte Relais2pin = 6; // Relais 2 für Vertikale Achse, Zylinder einfahren

const byte Endschalter3HEVS = 7; // Horizontal Endschalter vorne, schließer
const byte Endschalter4HEHS = 8; // Horizontal Endschalter hinten, schließer
const byte Endschalter4HEHOE = 9; // Horizontal Endschalter hinten, öffner

const byte Relais3pin = 10; // Relais 3 für Horizontal Achse, Zylinder ausfahren
const byte Relais4pin = 11; // Relais 4 für Horizontal Achse, Zylinder einfahren

// LDR Stiftverbindungen am Analogpin, LDR5528, GL5528, 0,5-200kOhm, 5mm
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

// Feste Werte
const int START = 300; // Wert ab wann das Programm wieder Startet (jeder Einzelner LDR)
const int TOLV = 170; // Wert, ab wann die Position Veretikal geändert werden soll (Toleranz)
const int TOLH = 170; // Wert, ab wann die Position Horizontal geändert werden soll (Toleranz)
const int ENDEV = 10; // Wert zum Beenden der Ausrichtung Vertikal
const int ENDEH = 10; // Wert zum Beenden der Ausrichtung Horizontal
const int NACHT = 55; // Wert ab wann die Linearmotoren in Startposition fahren (Progamm bei Dunkelheit beendet, jeder Einzelner LDR)

void setup ()
{
  pinMode(Endschalter1VEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEOOE, INPUT); // Pin Modus definieren, Eingang, öffner

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

  pinMode(Endschalter3HEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHOE, INPUT); // Pin Modus definieren, Eingang, öffner

  pinMode(Relais3pin, OUTPUT); // Pin Modus definieren, Ausgang
  pinMode(Relais4pin, 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 GWO = (OL + OR); // Gesamtwert oben
  int GWU = (UL + UR); // Gesamtwert unten
  int GWL = (OL + UL); // Gesamtwert links
  int GWR = (OR + UR); // Gesamtwert rechts

  int DVERT = abs(GWO - GWU); // Überprüfen der Diffirenz zwischen oben und unten, Vertikal, immer Positiv setzen
  int DHORIZ = abs(GWL - GWR); // Überprüfen der Diffirenz zwischen links und rechts, Horizontal, immer Positiv setzen

  bool Endschalter1VEVSStatus = digitalRead(Endschalter1VEVS); // Zustand des Endschalter Vertikal vorne, schließer
  bool Endschalter2VEHSStatus = digitalRead(Endschalter2VEHS); // Zustand des Endschalter Vertikal hinten, schließer
  bool Endschalter2VEOOEStatus = digitalRead(Endschalter2VEOOE); // Zustand des Endschalter Vertikal hinten, öffner
  bool Endschalter3HEVSStatus = digitalRead(Endschalter3HEVS); // Zustand des Endschalter Horizontal vorne, schließer
  bool Endschalter4HEHSStatus = digitalRead(Endschalter4HEHS); // Zustand des Endschalter Horizontal hinten, schließer
  bool Endschalter4HEHOEStatus = digitalRead(Endschalter4HEHOE); // Zustand des Endschalter Horizontal hinten, öffner

  if ((OL > START) && (OR > START) && (UL > START) && (UR > START))
  {
    // Vertikalachse ausrichten, Linearmotor 3000N 200mm
    if  (DVERT > TOLV)
    {
      if ((GWO < GWU) && ((Endschalter2VEHSStatus == LOW) || (Endschalter2VEOOEStatus == HIGH))) // // je LDR über "START" Wert, "DVERT" größer "TOLV" Wert, oben heller wie unten, Endschalter 2 schließer und öffner nicht betätigt
      {
        digitalWrite(Relais1pin, HIGH); // Zylinder ausfahren
        digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
      }
      else if ((GWO > GWU) && (Endschalter1VEVSStatus == LOW)) // je LDR über "START" Wert, "DVERT" größer "TOLV" Wert, oben dunkler wie unten, Endschalter 1 schließer nicht betätigt ist
      {
        digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
        digitalWrite(Relais2pin, HIGH); // Zylinder einfahren
      }
    }
    // Vertikalachse ausrichten abgeschlossen und die Relais 1 und 2 deaktivieren
    if (DVERT <= ENDEV)) // LDR gesamt über "START" Wert, oben und unten gleich hell sind oder eine max. Differnz von "ENDEV" haben
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    if ((Endschalter2VEHSStatus == HIGH) || (Endschalter2VEOOEStatus == LOW)) && (digitalRead(Relais1pin) == HIGH) && (digitalRead(Relais2pin) == LOW)) // je LDR über "START" Wert, Endschalter 2 schließer und öffner betätigt, Relais 1 betätigt und Relais 2 aus
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    

Das ist etwas umgebasteltes.
Siehe alles was ich vorher schrieb.
Und dann schau Dir den Unterschied zu Deinem an.
Ich kann mich nicht in Deine Logik reindenken. Aber schreib nicht alles in eine Zeile, wenn es immer wieder vorkommt.
Suche Dir Gemeinsamkeiten und fasse sie in einem Teil zusammen.

Und wenn Du Deinen Sketch umgebaut hast, dann passe ich Dir den Sensor gerne ein.

1 Like

millis() ist doch im sketch drin, siehe meinem Beitrag oben... :thinking:

updaten

Danke für die Hilfreichen Tipps, habe meinen Sketch jetzt erstmal überarbeitet:

// Sonnen Verfolgung Vertikal und Horizontal v9.3 vom 19.06.2021

const byte Endschalter1VEVS = 2; // Vertikal Endschalter vorne, schließer
const byte Endschalter2VEHS = 3; // Vertikal Endschalter hinten, schließer
const byte Endschalter2VEOOE = 4; // Vertikal Endschalter hinten, öffner

const byte Relais1pin = 5; // Relais 1 für Vertikale Achse, Zylinder ausfahren
const byte Relais2pin = 6; // Relais 2 für Vertikale Achse, Zylinder einfahren

const byte Endschalter3HEVS = 7; // Horizontal Endschalter vorne, schließer
const byte Endschalter4HEHS = 8; // Horizontal Endschalter hinten, schließer
const byte Endschalter4HEHOE = 9; // Horizontal Endschalter hinten, öffner

const byte Relais3pin = 10; // Relais 3 für Horizontal Achse, Zylinder ausfahren
const byte Relais4pin = 11; // Relais 4 für Horizontal Achse, Zylinder einfahren

// LDR Stiftverbindungen am Analogpin, LDR5528, GL5528, 0,5-200kOhm, 5mm
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

// Feste Werte
const int START = 300; // Wert ab wann das Programm wieder Startet (jeder Einzelner LDR)
const int TOLV = 170; // Wert, ab wann die Position Veretikal geändert werden soll (Toleranz)
const int TOLH = 170; // Wert, ab wann die Position Horizontal geändert werden soll (Toleranz)
const int ENDEV = 10; // Wert zum Beenden der Ausrichtung Vertikal
const int ENDEH = 10; // Wert zum Beenden der Ausrichtung Horizontal
const int NACHT = 55; // Wert ab wann die Linearmotoren in Startposition fahren (Progamm bei Dunkelheit beendet, jeder Einzelner LDR)

void setup ()
{
  pinMode(Endschalter1VEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEOOE, INPUT); // Pin Modus definieren, Eingang, öffner

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

  pinMode(Endschalter3HEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHOE, INPUT); // Pin Modus definieren, Eingang, öffner

  pinMode(Relais3pin, OUTPUT); // Pin Modus definieren, Ausgang
  pinMode(Relais4pin, 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 GWO = (OL + OR); // Gesamtwert oben
  int GWU = (UL + UR); // Gesamtwert unten
  int GWL = (OL + UL); // Gesamtwert links
  int GWR = (OR + UR); // Gesamtwert rechts

  int DVERT = abs(GWO - GWU); // Überprüfen der Diffirenz zwischen oben und unten, Vertikal, immer Positiv setzen
  int DHORIZ = abs(GWL - GWR); // Überprüfen der Diffirenz zwischen links und rechts, Horizontal, immer Positiv setzen

  bool Endschalter1VEVSStatus = digitalRead(Endschalter1VEVS); // Zustand des Endschalter Vertikal vorne, schließer
  bool Endschalter2VEHSStatus = digitalRead(Endschalter2VEHS); // Zustand des Endschalter Vertikal hinten, schließer
  bool Endschalter2VEOOEStatus = digitalRead(Endschalter2VEOOE); // Zustand des Endschalter Vertikal hinten, öffner
  bool Endschalter3HEVSStatus = digitalRead(Endschalter3HEVS); // Zustand des Endschalter Horizontal vorne, schließer
  bool Endschalter4HEHSStatus = digitalRead(Endschalter4HEHS); // Zustand des Endschalter Horizontal hinten, schließer
  bool Endschalter4HEHOEStatus = digitalRead(Endschalter4HEHOE); // Zustand des Endschalter Horizontal hinten, öffner

  // Ausrichtung bei Helligkeit, Wert "START"
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START)) // LDR's alle über "START"
  {
    if (DVERT > TOLV) // "DVERT" größer "TOLV" Wert
    {
      // Vertikalachse ausrichten, Linearmotor 3000N 200mm
      if ((GWO < GWU) && ((Endschalter2VEHSStatus == LOW) || (Endschalter2VEOOEStatus == HIGH))) // Oben heller wie unten, Endschalter 2 schließer und öffner nicht betätigt
      {
        digitalWrite(Relais1pin, HIGH); // Zylinder ausfahren
        digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
      }
      else if ((GWO > GWU) && (Endschalter1VEVSStatus == LOW)) // Oben dunkler wie unten, Endschalter 1 schließer nicht betätigt ist
      {
        digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
        digitalWrite(Relais2pin, HIGH); // Zylinder einfahren
      }
    }


    // Vertikalachse ausrichten abgeschlossen und die Relais 1 und 2 deaktivieren
    if (DVERT <= ENDEV) // Oben und unten gleich hell sind oder eine max. Differnz von "ENDEV" haben
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    else if (((Endschalter2VEHSStatus == HIGH) || (Endschalter2VEOOEStatus == LOW)) && (digitalRead(Relais1pin) == HIGH) && (digitalRead(Relais2pin) == LOW)) // Endschalter 2 schließer und öffner betätigt, Relais 1 betätigt und Relais 2 aus
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    else if ((Endschalter1VEVSStatus == HIGH) && (digitalRead(Relais1pin) == LOW) && (digitalRead(Relais2pin) == HIGH)) // Endschalter 1 schließer betätigt, Relais 1 aus und Relais 2 betätigt ist
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }


    // Horizontalachse ausrichten, Linearmotor 3000N 100mm
    if (DHORIZ > TOLH) // "DHORIZ" größer "TOLH" Wert
    {
      if ((GWL > GWR) && ((Endschalter4HEHSStatus == LOW) || (Endschalter4HEHOEStatus == HIGH))) // Rechts heller wie links, Endschalter 4 schließer und öffner nicht betätigt
      {
        digitalWrite(Relais3pin, HIGH); // Zylinder ausfahren
        digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
      }
      else if ((GWL < GWR) && (Endschalter3HEVSStatus == LOW)) // Rechts dunkler wie links, Endschalter 3 schließer nicht betätigt
      {
        digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
        digitalWrite(Relais4pin, HIGH); // Zylinder einfahren
      }
    }


    // Horizontalachse ausrichten abgeschlossen und die Relais 3 und 4 deaktivieren
    if (DHORIZ <= ENDEH) // Oben und unten gleich hell sind oder eine max. Differnz von "ENDEH" haben
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
    else if (((Endschalter4HEHSStatus == HIGH) || (Endschalter4HEHOEStatus == LOW)) && (digitalRead(Relais3pin) == HIGH) && (digitalRead(Relais4pin) == LOW)) // Endschalter 4 schließer und öffner betätigt, Relais 3 betätigt und Relais 4 aus
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
    else if ((Endschalter3HEVSStatus == HIGH) && (digitalRead(Relais3pin) == LOW) && (digitalRead(Relais4pin) == HIGH)) // Endschalter 3 schließer betätigt, Relais 3 aus und Relais 4 betätigt ist
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
  }


  // Grundstellung bei Dunkelheit, Wert "NACHT"
  if ((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT)) // LDR's alle unter "NACHT"
  {
    if (Endschalter1VEVSStatus == LOW)// Endschalter 1 schließer nicht betätigt, fährt die Vertikalachse in die Startposition
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, HIGH); // Zylinder einfahren, Vertikal
    }
    if (Endschalter1VEVSStatus == HIGH) // Endschalter 1 schließer betätigt
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    if (Endschalter3HEVSStatus == LOW)// Endschalter 3 schließer nicht betätigt, fährt die Horizontalachse in die Startposition
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, HIGH); // Zylinder einfahren, Horizontal
    }
    if (Endschalter3HEVSStatus == HIGH) // Endschalter 3 schließer betätigt
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
  }

  // Die 4 Helligkeitswerte, Berechnung der Helligkeitswerte, Relais und die Endschalterzustände zu Testzwecken an den PC übertragen
  static unsigned long lastprint;
  if (millis() - lastprint > 3000) // Testausgabe alle 3s
  {
    lastprint = millis();
    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("GWO:"); Serial.print(GWO); // Gesamtwert oben
    Serial.print(" GWU:"); Serial.println(GWU); // Gesamtwert unten
    Serial.print("GWL:"); Serial.print(GWL); // Gesamtwert links
    Serial.print(" GWR:"); Serial.println(GWR); // Gesamtwert rechts
    Serial.print("Diff O & U:"); Serial.print(DVERT); // Diffirence zwischen oben und unten
    Serial.print(" Diff L & R:"); Serial.println(DHORIZ); // Diffirence zwischen links und rechts
    Serial.print("Relais 1:"); Serial.print(digitalRead(Relais1pin)); // Zustand Relais 1
    Serial.print(" Relais 2:"); Serial.println (digitalRead(Relais2pin)); // Zustand Relais 1
    Serial.print("Relais 3:"); Serial.print(digitalRead(Relais3pin)); // Zustand Relais 1
    Serial.print(" Relais 4:"); Serial.println (digitalRead(Relais4pin)); // Zustand Relais 1
    Serial.print("Endschalter1VEVS:");
    if (Endschalter1VEVSStatus == LOW) // Vertikal Endschalter vorne betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter1VEVSStatus == HIGH) // Vertikal Endschalter vorne nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
    Serial.print("Endschalter2VEHS:");
    if (Endschalter2VEHSStatus == LOW) // Vertikal Endschalter hinten betätigt kommt die Ausgabe 0
    {
      Serial.print("0");
    }
    else if (Endschalter2VEHSStatus == HIGH) // Vertikal Endschalter hinten nicht betätigt kommt die Ausgabe 1
    {
      Serial.print("1");
    }
    Serial.print(" Endschalter2VEOOE:");
    if (Endschalter2VEOOEStatus == LOW) // Vertikal Endschalter hinten betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter2VEOOEStatus == HIGH) // Vertikal Endschalter hinten nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
    Serial.print("Endschalter3HEVS:");
    if (Endschalter3HEVSStatus == LOW) // Vertikal Endschalter vorne betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter3HEVSStatus == HIGH) // Vertikal Endschalter vorne nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
    Serial.print("Endschalter4HEHS:");
    if (Endschalter4HEHSStatus == LOW) // Vertikal Endschalter hinten betätigt kommt die Ausgabe 0
    {
      Serial.print("0");
    }
    else if (Endschalter4HEHSStatus == HIGH) // Vertikal Endschalter hinten nicht betätigt kommt die Ausgabe 1
    {
      Serial.print("1");
    }
    Serial.print(" Endschalter4HEHOE:");
    if (Endschalter4HEHOEStatus == LOW) // Vertikal Endschalter oben betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter4HEHOEStatus == HIGH) // Vertikal Endschalter oben nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }
  }
}

Manchmal sieht man es gar nicht, das einige Bedingungen zusammen gefast werden können…test läuft :wink:

Moin,

Na dann baun wa das noch kleiner....
Frage: Das kann doch eigentlich nicht kleiner als 0 werden....
int OL
Dann mach daraus unsigned int.
Das dann mit allen anderen auch.

Dann gibt es Einsparpotenzial:

    if (Endschalter1VEVSStatus == LOW) // Vertikal Endschalter vorne betätigt kommt die Ausgabe 0
    {
      Serial.println("0");
    }
    else if (Endschalter1VEVSStatus == HIGH) // Vertikal Endschalter vorne nicht betätigt kommt die Ausgabe 1
    {
      Serial.println("1");
    }

LOW ist 0 und HIGH ist 1.
Das brauchst nicht abfragen, sondern schreibst ins Serial.println(Endschalter1VEVSStatus);

Macht nochmal ne Menge Zeilen und dann sehe ich das schon auf gutem Weg.

Ich muss mich erstmal aklimatisieren - also irgend wann auf'm Abend schmeiss ich den Sensor da rein....

1 Like

Oh, er lebt in der Zukunft :wink:

1 Like

Ist mir auch gerade aufgefallen :grinning:...

Abkühlen ist bei dem Wetter immer gut...

So jetzt ist das auch geändert...
Sollte so richtig sein:

// Sonnen Verfolgung Vertikal und Horizontal v9.4 vom 19.06.2021

const byte Endschalter1VEVS = 2; // Vertikal Endschalter vorne, schließer
const byte Endschalter2VEHS = 3; // Vertikal Endschalter hinten, schließer
const byte Endschalter2VEOOE = 4; // Vertikal Endschalter hinten, öffner

const byte Relais1pin = 5; // Relais 1 für Vertikale Achse, Zylinder ausfahren
const byte Relais2pin = 6; // Relais 2 für Vertikale Achse, Zylinder einfahren

const byte Endschalter3HEVS = 7; // Horizontal Endschalter vorne, schließer
const byte Endschalter4HEHS = 8; // Horizontal Endschalter hinten, schließer
const byte Endschalter4HEHOE = 9; // Horizontal Endschalter hinten, öffner

const byte Relais3pin = 10; // Relais 3 für Horizontal Achse, Zylinder ausfahren
const byte Relais4pin = 11; // Relais 4 für Horizontal Achse, Zylinder einfahren

// LDR Stiftverbindungen am Analogpin, LDR5528, GL5528, 0,5-200kOhm, 5mm
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

// Feste Werte
const int START = 300; // Wert ab wann das Programm wieder Startet (jeder Einzelner LDR)
const int TOLV = 170; // Wert, ab wann die Position Veretikal geändert werden soll (Toleranz)
const int TOLH = 170; // Wert, ab wann die Position Horizontal geändert werden soll (Toleranz)
const int ENDEV = 10; // Wert zum Beenden der Ausrichtung Vertikal
const int ENDEH = 10; // Wert zum Beenden der Ausrichtung Horizontal
const int NACHT = 55; // Wert ab wann die Linearmotoren in Startposition fahren (Progamm bei Dunkelheit beendet, jeder Einzelner LDR)

void setup ()
{
  pinMode(Endschalter1VEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter2VEOOE, INPUT); // Pin Modus definieren, Eingang, öffner

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

  pinMode(Endschalter3HEVS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHS, INPUT); // Pin Modus definieren, Eingang, schließer
  pinMode(Endschalter4HEHOE, INPUT); // Pin Modus definieren, Eingang, öffner

  pinMode(Relais3pin, OUTPUT); // Pin Modus definieren, Ausgang
  pinMode(Relais4pin, 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 GWO = (OL + OR); // Gesamtwert oben
  int GWU = (UL + UR); // Gesamtwert unten
  int GWL = (OL + UL); // Gesamtwert links
  int GWR = (OR + UR); // Gesamtwert rechts

  int DVERT = abs(GWO - GWU); // Überprüfen der Diffirenz zwischen oben und unten, Vertikal, immer Positiv setzen
  int DHORIZ = abs(GWL - GWR); // Überprüfen der Diffirenz zwischen links und rechts, Horizontal, immer Positiv setzen

  bool Endschalter1VEVSStatus = digitalRead(Endschalter1VEVS); // Zustand des Endschalter Vertikal vorne, schließer
  bool Endschalter2VEHSStatus = digitalRead(Endschalter2VEHS); // Zustand des Endschalter Vertikal hinten, schließer
  bool Endschalter2VEOOEStatus = digitalRead(Endschalter2VEOOE); // Zustand des Endschalter Vertikal hinten, öffner
  bool Endschalter3HEVSStatus = digitalRead(Endschalter3HEVS); // Zustand des Endschalter Horizontal vorne, schließer
  bool Endschalter4HEHSStatus = digitalRead(Endschalter4HEHS); // Zustand des Endschalter Horizontal hinten, schließer
  bool Endschalter4HEHOEStatus = digitalRead(Endschalter4HEHOE); // Zustand des Endschalter Horizontal hinten, öffner

  // Ausrichtung bei Helligkeit, Wert "START"
  if ((OL > START) && (OR > START) && (UL > START) && (UR > START)) // LDR's alle über "START"
  {
    if (DVERT > TOLV) // "DVERT" größer "TOLV" Wert
    {
      // Vertikalachse ausrichten, Linearmotor 3000N 200mm
      if ((GWO < GWU) && ((Endschalter2VEHSStatus == LOW) || (Endschalter2VEOOEStatus == HIGH))) // Oben heller wie unten, Endschalter 2 schließer und öffner nicht betätigt
      {
        digitalWrite(Relais1pin, HIGH); // Zylinder ausfahren
        digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
      }
      else if ((GWO > GWU) && (Endschalter1VEVSStatus == LOW)) // Oben dunkler wie unten, Endschalter 1 schließer nicht betätigt ist
      {
        digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
        digitalWrite(Relais2pin, HIGH); // Zylinder einfahren
      }
    }


    // Vertikalachse ausrichten abgeschlossen und die Relais 1 und 2 deaktivieren
    if (DVERT <= ENDEV) // Oben und unten gleich hell sind oder eine max. Differnz von "ENDEV" haben
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    else if (((Endschalter2VEHSStatus == HIGH) || (Endschalter2VEOOEStatus == LOW)) && (digitalRead(Relais1pin) == HIGH) && (digitalRead(Relais2pin) == LOW)) // Endschalter 2 schließer und öffner betätigt, Relais 1 betätigt und Relais 2 aus
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    else if ((Endschalter1VEVSStatus == HIGH) && (digitalRead(Relais1pin) == LOW) && (digitalRead(Relais2pin) == HIGH)) // Endschalter 1 schließer betätigt, Relais 1 aus und Relais 2 betätigt ist
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }


    // Horizontalachse ausrichten, Linearmotor 3000N 100mm
    if (DHORIZ > TOLH) // "DHORIZ" größer "TOLH" Wert
    {
      if ((GWL > GWR) && ((Endschalter4HEHSStatus == LOW) || (Endschalter4HEHOEStatus == HIGH))) // Rechts heller wie links, Endschalter 4 schließer und öffner nicht betätigt
      {
        digitalWrite(Relais3pin, HIGH); // Zylinder ausfahren
        digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
      }
      else if ((GWL < GWR) && (Endschalter3HEVSStatus == LOW)) // Rechts dunkler wie links, Endschalter 3 schließer nicht betätigt
      {
        digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
        digitalWrite(Relais4pin, HIGH); // Zylinder einfahren
      }
    }


    // Horizontalachse ausrichten abgeschlossen und die Relais 3 und 4 deaktivieren
    if (DHORIZ <= ENDEH) // Oben und unten gleich hell sind oder eine max. Differnz von "ENDEH" haben
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
    else if (((Endschalter4HEHSStatus == HIGH) || (Endschalter4HEHOEStatus == LOW)) && (digitalRead(Relais3pin) == HIGH) && (digitalRead(Relais4pin) == LOW)) // Endschalter 4 schließer und öffner betätigt, Relais 3 betätigt und Relais 4 aus
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
    else if ((Endschalter3HEVSStatus == HIGH) && (digitalRead(Relais3pin) == LOW) && (digitalRead(Relais4pin) == HIGH)) // Endschalter 3 schließer betätigt, Relais 3 aus und Relais 4 betätigt ist
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
  }


  // Grundstellung bei Dunkelheit, Wert "NACHT"
  if ((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT)) // LDR's alle unter "NACHT"
  {
    if (Endschalter1VEVSStatus == LOW)// Endschalter 1 schließer nicht betätigt, fährt die Vertikalachse in die Startposition
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, HIGH); // Zylinder einfahren, Vertikal
    }
    if (Endschalter1VEVSStatus == HIGH) // Endschalter 1 schließer betätigt
    {
      digitalWrite(Relais1pin, LOW); // Relais1 deaktivieren
      digitalWrite(Relais2pin, LOW); // Relais2 deaktivieren
    }
    if (Endschalter3HEVSStatus == LOW)// Endschalter 3 schließer nicht betätigt, fährt die Horizontalachse in die Startposition
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, HIGH); // Zylinder einfahren, Horizontal
    }
    if (Endschalter3HEVSStatus == HIGH) // Endschalter 3 schließer betätigt
    {
      digitalWrite(Relais3pin, LOW); // Relais3 deaktivieren
      digitalWrite(Relais4pin, LOW); // Relais4 deaktivieren
    }
  }

  // Die 4 LDR Werte, Berechnung der Helligkeitswerte, Relais und die Endschalterzustände zu Testzwecken an den PC übertragen
  static unsigned long lastprint;
  if (millis() - lastprint > 3000) // Testausgabe alle 3s
  {
    lastprint = millis();
    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("GWO:"); Serial.print(GWO); // Gesamtwert oben
    Serial.print(" GWU:"); Serial.println(GWU); // Gesamtwert unten
    Serial.print("GWL:"); Serial.print(GWL); // Gesamtwert links
    Serial.print(" GWR:"); Serial.println(GWR); // Gesamtwert rechts
    Serial.print("Diff O & U:"); Serial.print(DVERT); // Diffirence zwischen oben und unten
    Serial.print(" Diff L & R:"); Serial.println(DHORIZ); // Diffirence zwischen links und rechts
    Serial.print("Relais 1:"); Serial.print(digitalRead(Relais1pin)); // Zustand Relais 1
    Serial.print(" Relais 2:"); Serial.println(digitalRead(Relais2pin)); // Zustand Relais 1
    Serial.print("Relais 3:"); Serial.print(digitalRead(Relais3pin)); // Zustand Relais 1
    Serial.print(" Relais 4:"); Serial.println(digitalRead(Relais4pin)); // Zustand Relais 1
    Serial.print("Endschalter1VEVS:"); Serial.println(Endschalter1VEVSStatus); // Endschalter 1 schließer
    Serial.print("Endschalter2VEHS:"); Serial.print(Endschalter2VEHSStatus); // Endschalter 2 schließer
    Serial.print(" Endschalter2VEOOE:"); Serial.println(Endschalter2VEOOEStatus); // Endschalter 2 öffner
    Serial.print("Endschalter3HEVS:"); Serial.println(Endschalter3HEVSStatus); // Endschalter 3 schließer
    Serial.print("Endschalter4HEHS:"); Serial.print(Endschalter4HEHSStatus); // Endschalter 4 schließer
    Serial.print(" Endschalter4HEHOE:"); Serial.println(Endschalter4HEHOEStatus); // Endschalter 4 öffner
  }
}

Wäre cool, wenn ich das Programm für den Windmesser auch als extra Sketch habe. Wo man als Serielleausgabe dann die aktuelle Windgeschwindigkeit und dann die Windspitze der letzten z.B. 10min. hat, je nachdem was im Sketch als Zeit angegeben ist...

Ein Sketch ist ein vollständiges Programm vom ersten include bis zum letzten geschweifte Klammer zu.

In einem Arduino läuft immer nur ein einziger einsamer singulärer Sketch.

functions kann man dagegen so viele haben bis der Flashspeicher oder das RAM vollständig belegt ist.

"Wäre cool ..." scheint so eine Art versteckte Aufforderung zu sein
"kann mir das jemand mal eben komplett programmieren?"

Ja könnte ich - will ich aber nicht bei der Arbeitshaltung die ich da hinter deinem Posting vermute. Du müsstest schon einen Anfang machen und wenigstens einen Code-Entwurf haben und dann eine konkrete Frage stellen.
vgs

Nö.
Du hast den ersten Teil, mithin meine Frage, ignoriert.

Aber gut.
Dann mal noch ne Zwischenfrage:
Eigentlich soll das Ding doch in die Nachtstellung fahren?

Weil, dann ist es einfach:

if (((OL < NACHT) && (OR < NACHT) && (UL < NACHT) && (UR < NACHT)) || sturm()) // LDR's alle unter "NACHT" oder windig

Wo dann sturm() als Rückgabewert HIGH hat, wenn es zutrifft.

Wenn dem so ist, musst Du das auslösen der Hellseite vermeiden.

if ((OL > START) && (OR > START) && (UL > START) && (UR > START)) // LDR's alle über "START"

Mach Dir schon mal Gedanken, wie Du das löst.
Und wenn Du die Lösung hast, dann mach Dir Gedanken, wie Du beides vereinfachen kannst.

In der Zeit bau ich mal was...

1 Like

Ja und?
Das ist nicht versteckt, das ist offen.
Das ist mir lieber, als die Hausaufgaben, die mit jeder Lösung noch ne Frage aufwerfen.
Hier weiss ich woran ich bin.

Keiner muss.
Weder Du ...
... noch ich.

gebaut.
Ohne jegliche Garantie - ich bin zwar am heimatlichen, aber das Breadboard ist nicht frei und irgendwie sollst ja auch noch was mitnehmen.

Du wolltest Sketch. Du bekommst Sketch :wink:
Probier aus - sag wo's klemmt.

const byte windmesserPin = 3;                    // Muss ein Interrupt-Pin sein
volatile unsigned long unterbrechungszaehler;    // Ereignisse zählen

void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  attachInterrupt(digitalPinToInterrupt(windmesserPin), Unterbrechung, RISING);
}

void loop()
{
  static bool lastzustand = false;
  if (lastzustand != windabfrage())
  {
    lastzustand = !lastzustand;
    Serial.print(F("Neuer Zustand: "));
    Serial.println(lastzustand);
  }
}

bool windabfrage()
{
  static unsigned long lastmillis = 0;             // Merker für Auslöser
  const unsigned long messzeit = 3000;             // zeit in ms
  const unsigned long toleranzzeit = 100;          // mögliche Abweichung der tatsächlichen Messzeit ohne Auswirkungen

  const unsigned long sturmstartimpulse = 300;     // Hier die Anzahl der Impulse (je messzeit(!!!)) eingeben, ab wann zu windig
  const unsigned long sturmpause = 1000 * 60 * 10; // Zeit in ms die ohne Sturm vergehen muss bis zurückgesetzt wird
  static unsigned long sturmstart = 0;             // Startzeit der letzten Böe

  unsigned long impulse = 0;                       // zwischenspeicher
  unsigned long gemessenezeit = 0;                 // für Geschwindigkeit errechnen

  bool vielwind = true;                            // vom schlimmsten ausgehen
  gemessenezeit = millis() - lastmillis;           // Merken
  if (gemessenezeit >= messzeit)                   // vergleichen und dann in die Auswertung
  {
    Serial.println(F("Messzeit abgelaufen"));
    detachInterrupt(digitalPinToInterrupt(windmesserPin)); // Hierdrauf kann eigentlich verzichtet werden.
    unsigned long impulse = unterbrechungszaehler;
    unterbrechungszaehler = 0;
    attachInterrupt(digitalPinToInterrupt(windmesserPin), Unterbrechung, RISING); // in der Zeit kommen keine verpflichtenden Impulse
    lastmillis = millis();
    Serial.println(F("Werte erfasst:"));
    Serial.print(F("gemessene Zeit: "));
    Serial.println(gemessenezeit);
    Serial.print(F("Impulse aufgenommen: "));
    Serial.println(impulse);

    
    // Das ist fiktiv angesetzt um zu zeigen das auf Abweichungen reagiert werden muss
    if (gemessenezeit * toleranzzeit > (messzeit + toleranzzeit)*toleranzzeit)
    {
      impulse /= (gemessenezeit * toleranzzeit) / (messzeit * toleranzzeit);
    }
    Serial.print(F("Impulse nach Neuberechnung: "));
    Serial.println(impulse);
    // Ende fiktive Umrechnung - bei gemessene Zeit <= messzeit+toleranz darf es zu keiner "Neuberechnung" kommen

    
  }
  if (impulse > sturmstartimpulse)                 // Es ist windig ...
  {
    sturmstart = millis();                         // ... merken ab wann ...
    vielwind = true;                               // ... es ist windig
  }
  else if (millis() - sturmstart >= sturmpause)    // es ist nicht windig und Zeit ist abgelaufen ...
  {
    vielwind = false;                              // ... dann nicht
  }
  return vielwind;                                 // Und jetzt gib zurück, was Du weisst...
}

void Unterbrechung()
{
  unterbrechungszaehler++;
}
1 Like