Go Down

Topic: Millis Befehl, Steuerung Schattenbahnof.  (Read 2165 times) previous topic - next topic

agmue

Es sei denn die Loks kommen zu schnell hintereinander.
Das ist genau der Grund für die Verwendung von millis: Blockadearme Programmierung zur quasi parallelen Verarbeitung von Informationen.

Schleife { Gleis 1 → Gleis 2 → Gleis 3 → ... → Gleis n}



Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

MicroBahner

#31
Sep 22, 2020, 06:08 pm Last Edit: Sep 22, 2020, 06:16 pm by MicroBahner
Zu den MobaTools sehe ich mir an. Aber eigentlich möchte ich was eigenes machen und nicht copy und paste.
Du wirst merken, wenn Du dir das anschaust: Da ist nix mit Copy und Paste. Die MobaTools sind eine Library, so wie viele andere auch, die Du teilweise benutzt ohne es zu merken. Du programmierst ja auch nicht auf der nackten HW ;) .
Letzendlich sind es Klassen, die Du benutzen kannst, ohne selbst Klassen erstellen zu müssen. Es sind keine fertigen Lösungen (Allerdings sind Beispiele für die Nutzung dabei). Wenn Du so willst ist es ein Werkzeugkasten, der die vorhanden Werkzeuge der Arduino IDE ergänzt, und die Handhabung erleichtert ( aber auch die muss man erst lernen ).

Die Logik deines Programms kommt immer noch von Dir, da helfen die MobaTools nichts. Und auch z.B. die Logik, wie man delay-frei programmiert ändert sich nicht. In meinem Link oben habe ich versucht, das Modellbahner-like zu erklären. Das musst Du verstehen. Nur das Werkzeug dafür ist leichter zu handhaben als die millis.
Das Verständnis für Funktionen, Arrays und später evtl. Strukturen und Klassen nehmen dir die MobaTools auch nicht ab. C++ lernen musst Du trotzdem ;) .
Gruß, Franz-Peter

kgbrus

#32
Sep 22, 2020, 07:07 pm Last Edit: Sep 22, 2020, 07:26 pm by kgbrus
Das ist genau der Grund für die Verwendung von millis: Blockadearme Programmierung zur quasi parallelen Verarbeitung von Informationen.

Schleife { Gleis 1 → Gleis 2 → Gleis 3 → ... → Gleis n}




Genau deshalb mache ich das ja ☺

Du wirst merken, wenn Du dir das anschaust: Da ist nix mit Copy und Paste. Die MobaTools sind eine Library, so wie viele andere auch, die Du teilweise benutzt ohne es zu merken. Du programmierst ja auch nicht auf der nackten HW ;) .
Letzendlich sind es Klassen, die Du benutzen kannst, ohne selbst Klassen erstellen zu müssen. Es sind keine fertigen Lösungen (Allerdings sind Beispiele für die Nutzung dabei). Wenn Du so willst ist es ein Werkzeugkasten, der die vorhanden Werkzeuge der Arduino IDE ergänzt, und die Handhabung erleichtert ( aber auch die muss man erst lernen ).

Die Logik deines Programms kommt immer noch von Dir, da helfen die MobaTools nichts. Und auch z.B. die Logik, wie man delay-frei programmiert ändert sich nicht. In meinem Link oben habe ich versucht, das Modellbahner-like zu erklären. Das musst Du verstehen. Nur das Werkzeug dafür ist leichter zu handhaben als die millis.
Das Verständnis für Funktionen, Arrays und später evtl. Strukturen und Klassen nehmen dir die MobaTools auch nicht ab. C++ lernen musst Du trotzdem ;) .
Dann nehme ich die ☺

Das wird etwas dauern, aber das bekomme ich schon hin.

Ps Super Hilfsbereit seid ihr!!!

kgbrus

Vielen Dank für die Hilfe, ich hab jetzt die delay Version mit einer Funktion versehen, die ich an entsprechender Stelle im Programmablauf aufrufe.

Code: [Select]
/* Weichenschaltung der Gleise 1 -5 Version 2_1
                Funktionen:
                1. Weichenschaltung neu komplett neu aufgesetzt
                2. Programm läuft immer nur, wenn Zug in SBH einfährt (LSHaupt)
                3. Programmierung LS Haupt
                4. V6.0
                5. V7.0 funktioniert nicht.
                6.V8.0 Einzelne Zeilen im Programm durch Funktion ersetzt
*/
// Umbenenen der STM Pins



// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const int LSBG1 = PA8;   // Lichtschranke Gleisbesetzt Gleis 1
const int LSBG2 = PB15;   // Lichtschranke Gleisbesetzt Gleis 2
const int LSBG3 = PB14;   // Lichtschranke Gleisbesetzt Gleis 3
const int LSBG4 = PB13;   // Lichtschranke Gleisbesetzt Gleis 4
const int LSBG5 = PB12;   // Lichtschranke Gleisbesetzt Gleis 5
int LSBG1State = 0;
int LSBG2State = 0;
int LSBG3State = 0;
int LSBG4State = 0;
int LSBG5State = 0;


// Lichtschranke SBH Haupt
const int LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH
int LSHauptState = 0;



// Ausgänge für Relais  der Weichenstellung weiche 1-5
const int W1A = PA0;          // Weiche 1 Abbiegen
const int W1G = PA1;          // Weiche 1 Geradeaus
const int W2A = PA2;          // Weiche 2 Abbiegen
const int W2G = PA3;          // Weiche 2 Geradeaus
const int W3A = PA4;          // Weiche 3 Abbiegen
const int W3G = PA5;          // Weiche 3 Geradeaus
const int W4A = PA6;          // Weiche 4 Abbiegen
const int W4G = PA7;          // Weiche 4 Geradeaus
const int WHauptA = PB0;      // Hauptweiche Abbiegen
const int WHauptG = PB1;     // Hauptweiche Geradeaus
int W1AState = 0;
int W1GState = 0;
int W2AState = 0;
int W2GState = 0;
int W3AState = 0;
int W3GState = 0;
int W4AState = 0;
int W4GState = 0;
int W5AState = 0;
int W5GState = 0;
int WHauptAState = 0;
int WHauptGState = 0;


// variable definieren
// Variablen Relais Ausgaänge für Weichen
bool geschaltetW1A = false;        // Variable für Weiche1 Abbiegen
bool geschaltetW1G = false;        // Variable für Weiche1 Geradeaus
bool geschaltetW2A = false;        // Variable für Weiche2 Abbiegen
bool geschaltetW2G = false;        // Variable für Weiche2 Geradeaus
bool geschaltetW3A = false;        // Variable für Weiche3 Abbiegen
bool geschaltetW3G = false;        // Variable für Weiche3 Geradeaus
bool geschaltetW4A = false;        // Variable für Weiche4 Abbiegen
bool geschaltetW4G = false;        // Variable für Weiche4 Geradeaus
bool geschaltetW5A = false;        // Variable für Weiche5 Abbiegen
bool geschaltetW5G = false;        // Variable für Weiche5 Geradeaus
bool geschaltetWHauptA = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHauptG = false;    // Variable für Weiche3 Geradeaus

int empfindlichkeit = 200;


// Variablen für Lichtschranke Gleis besetzt

bool Gleisbesetzt1 = false;         // Variable für LSBG1
bool Gleisbesetzt2 = false;         // Variable für LSBG2
bool Gleisbesetzt3 = false;         // Variable für LSBG3
bool Gleisbesetzt4 = false;         // Variable für LSBG4
bool Gleisbesetzt5 = false;         // Variable für LSBG5
bool GleisbesetztAll1 = false;       // Variable für alle Gleise besetzt  Benutzt!
bool GleisbesetztAll2 = false;       // Variable für alle Gleise besetzt  Benutzt!
bool UnterbrechungWagon1 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon2 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon3 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon4 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon5 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen


unsigned long RELAIS1G_timestore;  // Variable Speicher für Systemzeit.Weiche1
unsigned long RELAIS1A_timestore;
unsigned long RELAIS2G_timestore;  // Variable Speicher für Systemzeit.Weiche2
unsigned long RELAIS2A_timestore;
unsigned long RELAIS3G_timestore;  // Variable Speicher für Systemzeit.Weiche3
unsigned long RELAIS3A_timestore;
unsigned long RELAIS4G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS4A_timestore;
unsigned long RELAIS5G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS5A_timestore;
unsigned long RELAISHauptG_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAISHauptA_timestore;

// Variablen für die Counter damit Befehl nur einmal ausgeführt wird. Erst nach Zustandswechsel der LSBG wieder erneut
unsigned long CounterWHauptA = 0;
unsigned long CounterWHauptA1 = 0;
unsigned long CounterWHauptG = 0;
unsigned long CounterW1A = 0;
unsigned long CounterW1Ageschaltet = 0;
unsigned long CounterW2A = 0;
unsigned long CounterW3A = 0;
unsigned long CounterW4A = 0;
unsigned long CounterW5A = 0;



// Funktionen

void Weicheschalt(byte pin)                // Funktion zum Schalten der Weichen, diese wird bei bedarf aufgerufen
{
  digitalWrite (pin, HIGH);
  delay (1000);
  digitalWrite (pin, LOW);
}

void setup()
{
  // put your setup code here, to run once:



  // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
  pinMode(LSBG1, INPUT);
  pinMode(LSBG2, INPUT);
  pinMode(LSBG3, INPUT);
  pinMode(LSBG4, INPUT);
  pinMode(LSBG5, INPUT);
  pinMode(LSHaupt, INPUT);

  // Pin Mode für Lichtschranken Gleiseinfahrt Gleis 1 - 5 rausgenommen



  // Pin Mode für Gleis an schalten
  pinMode(W1A, OUTPUT);
  pinMode(W1G, OUTPUT);
  pinMode(W2A, OUTPUT);
  pinMode(W2G, OUTPUT);
  pinMode(W3A, OUTPUT);
  pinMode(W3G, OUTPUT);
  pinMode(W4A, OUTPUT);
  pinMode(W4G, OUTPUT);
  pinMode(WHauptA, OUTPUT);
  pinMode(WHauptG, OUTPUT);
}

void loop()
{

  LSHauptState = digitalRead(LSHaupt);                                         // Abfrage ob Zug einfährt. Lichtschranke an der Zufahrt
  if (LSHauptState == HIGH)
  {
    LSBG1State = digitalRead(LSBG1);                                            // abfrage ob SBH voll
    LSBG2State = digitalRead(LSBG2);
    LSBG3State = digitalRead(LSBG3);
    LSBG4State = digitalRead(LSBG4);
    LSBG5State = digitalRead(LSBG5);

    if (LSBG1State == HIGH && LSBG2State == HIGH && LSBG3State == HIGH && LSBG4State == HIGH && LSBG5State == HIGH)  // Abfrage ob alle Gleise besetzt sind
    {
      Weicheschalt(WHauptA);
    }
    else                                                                         // nicht alle Gleise sind besetzt
    {
      Weicheschalt(WHauptG);
    }

    LSBG1State = digitalRead(LSBG1);                                            // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      Weicheschalt(W1G);
    }
    if (LSBG1State == LOW)
    {
      Weicheschalt(W1A);
    }
    LSBG2State = digitalRead(LSBG2);                                            // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      Weicheschalt(W2G);
    }
    if (LSBG2State == LOW)
    {
      Weicheschalt(W2A);
    }
    LSBG3State = digitalRead(LSBG3);                                             // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      Weicheschalt(W3G);
    }
    if (LSBG3State == LOW)
    {
      Weicheschalt(W3A);
    }
    LSBG4State = digitalRead(LSBG4);                                               // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      Weicheschalt(W4G);
    }
    if (LSBG4State == LOW)
    {
      Weicheschalt(W4A);
    }
  }
}


Das funktioniert schon mal prima.

Als nächstes dann die Delay Funktion durch Millis ersetzten...

Gruß

Kay

kgbrus

Kleiner Nachtrag bzw Nachfrage:

Wird der Programmablauf durch die Verwendung von Funktionen beschleunigt?

Zumindest wirkt sich das hier so aus.
Beispiel:
Wenn ein Zug in den SBH einfährt schalte ich die Gleise hinter dem Zug (Einfahrt SBH) für 10 Sekunden ab, damit kein 2ter Zug in den SBH einfahren kann.
In der Programmversion ohne die Funktion, war die Zeitspanne zu kurz, sprich wenn der 2te Zug anfuhr reagierte das Programm nicht auf die Lichtschranke um die Weichen umzustellen.

Jetzt, also im Programm mit Funktion, reagiert der einwandfrei. Dann bräuchte ich in diesem Fall erstmal nicht auf millis umzustellen.

Gruß

Kay

MicroBahner

Hallo Kay,
Als nächstes dann die Delay Funktion durch Millis ersetzten...
mein Vorschlag wäre, als nächstes erstmal auf Arrays umzustellen. Das erleichtert alles was danach kommt ganz wesentlich.

Wird der Programmablauf durch die Verwendung von Funktionen beschleunigt?
Nein, prinzipiell nicht. Aber vielleicht hast Du bei der Umstellung den ganzen Ablauf geändert.
Gruß, Franz-Peter

kgbrus

Wenn ich das Prinzip der Arrays (Ein pool von Zahlen bzw Werten auf die man zugreifen kann) richtig verstanden habe, erkenne ich nicht wo ich die in meinem Programm sinnvoll nutzen kann.

Was kann/soll ich denn in meinem Programm auf Arrays umstellen?

Gruß

Kay

combie

#37
Sep 23, 2020, 09:49 am Last Edit: Sep 23, 2020, 09:50 am by combie
Quote
Was kann/soll ich denn in meinem Programm auf Arrays umstellen?
Du hast in deinem Programm durchnummerierte Variablen.
Weiche 1 bis 5 o.ä.

Das führt zu Codeduplikaten.
zu Copy&Paste Fehlern
erschwert die Wartung. (jeder Fehler muss an 5 Stellern korrigiert werden)

Das ist böse böse und nochmal böse.


Mein Rat:
Verschiedene Dinge in Strukturen
Gleiche artige Dinge in Arrays

Hier:
Alle Daten einer Weiche in eine Struktur.
Alle Weichen Strukturen in ein Array.
Heute war Gestern Morgen.
Heute ist Morgen Gestern.
Morgen ist Heute Gestern.
Gestern war Heute Morgen

MicroBahner

#38
Sep 23, 2020, 09:55 am Last Edit: Sep 23, 2020, 10:18 am by MicroBahner
Was kann/soll ich denn in meinem Programm auf Arrays umstellen?
Vom Prinzip her kannst Du alles, was Du in den Variablennamen durchnumerierst jeweils als ein Array definieren. Also z.B. statt
Code: [Select]
int W1AState = 0;
int W1GState = 0;
int W2AState = 0;
int W2GState = 0;
int W3AState = 0;
int W3GState = 0;
int W4AState = 0;
int W4GState = 0;
int W5AState = 0;
int W5GState = 0;
definierst Du 2 Arrays:
Code: [Select]
int WAState[5];
int WGState[5];
Das machst du überall, wo du die Namen durchnumeriert hast.

Edit: Da die Zahl der Arrayelemente fast überall gleich ist, und auch voneinander abhängt, solltest Du das auch am Anfang als Konstante definieren, und nicht überall fest z.B. die '5' reinschreiben.

Hinterher im Programm hast Du immer mehrere Anweisungsblöcke, die sich nur durch diese Nummer im Variablennamen unterscheiden. Da brauchst Du dann nur noch einen Anweisungsblock, bei dem Du in einer for-Schleife den Index durchzählst.
Das spart viel Tipperei, vermeidet Copy/Paste Fehler und lässt sich einfach erweitern/ändern. Gerade auch im Hinblick auf die Umstellung zum delay-freien Programmablauf. Auch deshalb solltest Du das vorher machen und als erstes angehen.

P.S. Combies Vorschlag mit Strukturen ist natürlich noch besser, erfordert aber auch erstmal das Verständnis für Strukturen. Da musst Du entscheiden ob Du dir dieses Wissen  aneignest bevor es weitergeht, oder ob Du es erstmal bei Arrays belässt.
Gruß, Franz-Peter

combie

Quote
Du entscheiden ob Du dir dieses Wissen  aneignest bevor es weitergeht, oder ob Du es erstmal bei Arrays belässt.
Da er da sowieso durch muss, plädiere ich dafür sofort das richtige zu lernen, als mit dem falschen anzufangen.

Umlernen ist immer schwieriger als sofort das richtige lernen.
Man bekommt Gewohnheiten und Falsches kaum wieder aus dem Kopf heraus. Gerade in Not, oder wenn man unsicher ist, fällt man zurück in alte Irrtümer.

Das hat evolutionäre Gründe, als noch hinter jedem Strauch ein Löwe lauern konnte. 
Da waren schnelle Entscheidungen ohne vollständiges Wissen erforderlich.
Das Verhalten ist beim Bau einer Modellbahn nicht wirklich erforderlich, ja, eher hinderlich.

Hier besteht die Chance sofort das richtige zu lernen.

Eine Weiche zu betrachten, diese in eine Struktur/Klasse zu stopfen.
Das dann auf viele Weichen in einem Array auszuweiten.
Heute war Gestern Morgen.
Heute ist Morgen Gestern.
Morgen ist Heute Gestern.
Gestern war Heute Morgen

MicroBahner

Da er da sowieso durch muss, plädiere ich dafür sofort das richtige zu lernen, als mit dem falschen anzufangen.

Umlernen ist immer schwieriger als sofort das richtige lernen.
Ok, sehe ich jetzt nicht ganz so eng. Würde in letzter Konsequenz bedeuten, dass man ein 1000 seitiges C++ Buch von Anfang bis Ende durcharbeiten muss, bevor man sein erstes Projekt starten dürfte. Denn mit jedem weiteren Wissen dürfte das Projekt am Ende anders aussehen.

Letzendlich muss er das entscheiden. Der Schritt von seinem Code-Wust zu den Arrays ist auf jeden Fall größer und bringt mehr als dann der Schritt zu Strukturen. Andererseits - soo kompliziert ist das mit den Strukturen jetzt auch nicht ...
Gruß, Franz-Peter

combie

#41
Sep 23, 2020, 11:01 am Last Edit: Sep 23, 2020, 11:04 am by combie
Hach... ich weiß....

Halte allerdings Strukturen für wichtiger, als Arrays.
Ist allerdings nur eine persönliche Einstellung.


Im Grunde hangelt man sich sowieso von Fehler zu Fehler.
Es ist jeweils interessant, wie lange man im Fehler verharrt.
Denn verharren wird zur Gewohnheit.
Und damit zementiert es.

Youtube Tipp:  "Kate Gregory Stop Teaching C"
Heute war Gestern Morgen.
Heute ist Morgen Gestern.
Morgen ist Heute Gestern.
Gestern war Heute Morgen

kgbrus

Nicht streiten :-)

Vielleicht etwas allgemeines, ich will nicht der C++ Guru werden und werde auch nicht, glaub ich, Seitenweise Programme schreiben.
Ich möchte nur Abläufe auf meiner analogen Modellbahn steuern. Das von mir verwendete Board hat "nur" 26 ein bzw Ausgänge. Sprich die Programme werden eher klein bleiben.

Ich möchte auch keinen verschrecken, der mir Tips gibt weil ich Dinge (erstmal) nicht umsetzte.

Deshalb auch nochmals zu den Arrays zurück. Die machen doch hauptsächlich Sinn, wenn Variablen im Programm mehrfach auftauchen?
Die Variablen für die Weichen (zB W1A) tauchen aber nur einmal auf.

Bei Funktionen ist es mir klar, anstelle von 10 mal 3 Anweisungen. nur 1 mal 3 Anweisungen und auf die von 10 Verschiedenen Stellen zugreifen.

Gruß

Kay

MicroBahner

Nicht streiten :-)
Wer streitet hier :) ?

Deshalb auch nochmals zu den Arrays zurück. Die machen doch hauptsächlich Sinn, wenn Variablen im Programm mehrfach auftauchen?
Nein, das hat damit nichts zu tun.

Die Variablen für die Weichen (zB W1A) tauchen aber nur einmal auf.
zum einen taucht auch die mehrfach auf, zum anderen geht es darum, dass Du auch noch W2A, W3A und W4A hast. Und die kannst Du alle in einem Array zusammenfassen.

Mit Arrays wird z.B. aus diesem Bandwurm:
Code: [Select]
   LSBG1State = digitalRead(LSBG1);                                            // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      Weicheschalt(W1G);
    }
    if (LSBG1State == LOW)
    {
      Weicheschalt(W1A);
    }
    LSBG2State = digitalRead(LSBG2);                                            // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      Weicheschalt(W2G);
    }
    if (LSBG2State == LOW)
    {
      Weicheschalt(W2A);
    }
    LSBG3State = digitalRead(LSBG3);                                             // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      Weicheschalt(W3G);
    }
    if (LSBG3State == LOW)
    {
      Weicheschalt(W3A);
    }
    LSBG4State = digitalRead(LSBG4);                                               // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      Weicheschalt(W4G);
    }
    if (LSBG4State == LOW)
    {
      Weicheschalt(W4A);
    }


diese kurze Schleife:
Code: [Select]
   for ( int GleisIx = 0; GleisIx<AnzahlGLeise, GleisIx++ ) {
    LSBGState[GleisIx] = digitalRead(LSBG[GleisIx]);         // Abfrage ob Zug auf GleisIx steht.
    if (LSBGState[GleisIx] == HIGH)
    {
      Weicheschalt(WG[GleisIx]);
    }
    if (LSBGState[GleisIx] == LOW)
    {
      Weicheschalt(WA[GleisIx]);
    }
  }

Und das hast Du an vielen Stellen so!
Gruß, Franz-Peter

agmue

#44
Sep 23, 2020, 11:48 am Last Edit: Sep 23, 2020, 01:13 pm by agmue
Was kann/soll ich denn in meinem Programm auf Arrays umstellen?
Ohne Veränderung der Logik könnte es so aussehen (ungetestet):

Code: [Select]
const byte AnzahlGleise = 5;
const byte AnzahlWeichen = AnzahlGleise - 1;
enum {Gleis1, Gleis2, Gleis3, Gleis4, Gleis5};

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};
bool LSBGState[AnzahlGleise] = {0, 0, 0, 0, 0};

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH
bool LSHauptState = 0;

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlWeichen] = {PA0, PA2, PA4, PA6};          // Weichen Abbiegen
const byte WG[AnzahlWeichen] = {PA1, PA3, PA5, PA7};          // Weichen Geradeaus
const byte WHauptA = PB0;      // Hauptweiche Abbiegen
const byte WHauptG = PB1;     // Hauptweiche Geradeaus
bool WAState[AnzahlWeichen] = {0, 0, 0, 0};
bool WGState[AnzahlWeichen] = {0, 0, 0, 0};
bool WHauptAState = 0;
bool WHauptGState = 0;

// variable definieren
// Variablen Relais Ausgaänge für Weichen
bool geschaltetWA[AnzahlGleise] = {false, false, false, false, false};    // Variable für Weichen Abbiegen
bool geschaltetWG[AnzahlGleise] = {false, false, false, false, false};    // Variable für Weichen Geradeaus
bool geschaltetWHauptA = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHauptG = false;    // Variable für Weiche3 Geradeaus

unsigned long RELAISA_timestore[AnzahlGleise] = {0, 0, 0, 0, 0}; // Variable Speicher für Systemzeit.Weichen Abbiegen
unsigned long RELAISG_timestore[AnzahlGleise] = {0, 0, 0, 0, 0}; // Variable Speicher für Systemzeit.Weichen Geradeaus
unsigned long RELAISHauptA_timestore;
unsigned long RELAISHauptG_timestore;

// Variablen für die Counter damit Befehl nur einmal ausgeführt wird. Erst nach Zustandswechsel der LSBG wieder erneut
unsigned long CounterWHauptA = 0;
unsigned long CounterWHauptA1 = 0;
unsigned long CounterWHauptG = 0;
unsigned long CounterW1A = 0;
unsigned long CounterW1Ageschaltet = 0;
unsigned long CounterW2A = 0;
unsigned long CounterW3A = 0;
unsigned long CounterW4A = 0;
unsigned long CounterW5A = 0;

void setup()
{
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
    pinMode(LSBG[g], INPUT);
  }
  pinMode(LSHaupt, INPUT);

  for (byte w = 0; w < AnzahlWeichen; w++)
  {
    // Pin Mode für Gleis an schalten
    pinMode(WA[w], OUTPUT);
    pinMode(WG[w], OUTPUT);
  }
  pinMode(WHauptA, OUTPUT);
  pinMode(WHauptG, OUTPUT);
}

void loop()
{
  LSHauptState = digitalRead(LSHaupt);     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
  if (LSHauptState == HIGH)
  {
    for (byte g = 0; g < AnzahlGleise; g++)
    {
      LSBGState[g] = digitalRead(LSBG[g]);    // abfrage ob SBH voll
    }

    if (LSBGState[Gleis1] == HIGH && LSBGState[Gleis2] == HIGH && LSBGState[Gleis3] == HIGH && LSBGState[Gleis4] == HIGH && LSBGState[Gleis5] == HIGH) // Abfrage ob alle Gleise besetzt sind
    {
      digitalWrite (WHauptA, HIGH);
      RELAISHauptA_timestore = millis();
    }
    if (millis() - RELAISHauptA_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptA, LOW);
      WHauptAState = LOW;
    }

    else
      //    if (LSBGState[Gleis1] == LOW || LSBG2State == LOW || LSBG3State == LOW || LSBG4State == LOW || LSBG5State == LOW)  // Abfrage ob alle Gleise besetzt sind                                          // nicht alle Gleise sind besetzt
    {
      digitalWrite (WHauptG, HIGH);
      RELAISHauptG_timestore = millis();
    }
    if (millis() - RELAISHauptG_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptG, LOW);
      WHauptGState = LOW;
    }

    for (byte g = 0; g < AnzahlGleise; g++)
    {
      LSBGState[g] = digitalRead(LSBG[g]);  // Abfrage ob Zug auf Gleis g steht.
      if (LSBGState[g] == HIGH)
      {
        digitalWrite (WG[g], HIGH);
        RELAISG_timestore[g] = millis();
      }

      if (millis() - RELAISG_timestore[g] > 1000 ) //Schaltzeit Relais 1 Sek.
      {
        digitalWrite(WG[g], LOW);
        WGState[g] = LOW;
      }

      if (LSBGState[g] == LOW)
      {
        digitalWrite (WA[g], HIGH);
        RELAISA_timestore[g] = millis();
      }

      if (millis() - RELAISA_timestore[g] > 1000 ) //Schaltzeit Relais
      {
        digitalWrite(WA[g], LOW);
        WAState[g] = LOW;
      }
    }
  }
}
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Go Up