Millis Befehl, Steuerung Schattenbahnof.

Hallo zusammen,

zunächst möchte ich mich kurz Vorstellen, mein Name ist Kay bin 53 Jahre alt und mache die ersten Gehversuche mit Arduino. Ich benutze den Arduino STM32F103.

2 Programme hab ich schon gemacht um meine Modellbahn zu steuern.

Ich verzweifle immer an der Stelle, wenn ich den "delay" Befehl durch "Millis" ersetzen will. Mal klappt es mal nicht. Trotz mehrfaches ausprobieren der Nachtwächterschaltung und Blink without delay kapiere ich das einfach nicht.
Ev hilft es mir ja, wenn mir jemand von euch sagt, was an meinem Code falsch ist.

 LSBG1State = digitalRead(LSBG1);  // Abfrage ob Zug auf Gleis 1 steht.
            if (LSBG1State == HIGH)
                  {
                    digitalWrite (W1G, HIGH);
                   RELAIS1G_timestore = millis();
                  }
                
                 if (millis() - RELAIS1G_timestore> 1000 ) //Schaltzeit Relais 1 Sek.
                   {
                      digitalWrite(W1G, LOW);
                      W1GState = LOW;
                   }

W1G ist der Ausgang für ein Relais, dieses soll für 1 Sekunde anziehen und dann wieder abfallen.

Das Relais zieht an, fällt aber nicht mehr ab. Ich verzweifel hier gerade..

Gruß

Kay

Hallo,

der STM32F103 ist doch sicher der Controller und als Arduino hat der bestimmt einen anderen Namen.

Poste einfach mal einen Link deines Boards, das ist dann verständlicher.

der STM32F103 ist doch sicher der Controller und als Arduino hat der bestimmt einen anderen Namen.

Es gibt keine Arduinos mit STM32F103

Der übliche Name ist "Blue Pill Board"
Suche mal danach, und du wirst erschlagen.

a) mit codeschnippseln tun wir uns schwer.
b) drücke mal STRG-T in deiner IDE und mach die Einrückungen schön
c) statte deinen Code halt mit Serial.print Ausgaben aus, und verfolge welche deine Bedingungen erfüllt ist und dann siehst du auch warum dein Code nicht macht was du dir vorstellst.

VERMUTLICH ist halt LSBG1State noch immer High, daher ist die erste Bedingung wieder erfüllt und es schaltet ein.
Solche Sachen erkennst du aber schön mit Serial.print Ausgaben und kannst daher deine Logik anpassen.

add on: wenn das Weichenantriebe sind, dann würde ich da einen anderen Ansatz verfolgen...

combie:
Es gibt keine Arduinos mit STM32F103

Der übliche Name ist "Blue Pill Board"
Suche mal danach, und du wirst erschlagen.

Danke....dann lass ich es lieber. :wink:

Zunächst einmal vielen Dank für die Antworten und die Hilfe,

es handelt sich um dieses "Bluepill" Development Board Modul mit ARM Cortex M3 Prozessor – AZ-Delivery

Board und da ist doch ein STM32F103 drauf? Entschuldigt, wenn ich mich da falsch ausgedrückt habe.

Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :slight_smile:

Soll ich den kompletten code hier rein kopieren? incl setup? Meine Frage lautet, ob ich im Code einen Fehler gemacht habe, da der teil ab If (millis) wohl vom Programm ignoriert wird.

Gruß

Kay

kgbrus:
Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :slight_smile:

So wie er jetzt ist, werden wohl mögliche Helfer nichts finden.

kgbrus:
Soll ich den kompletten code hier rein kopieren? incl setup?

Ja.

Gruß Tommy

kgbrus:
Board und da ist doch ein STM32F103 drauf? Entschuldigt, wenn ich mich da falsch ausgedrückt habe.

Der Controller ist drauf, aber es ist kein Arduino.

Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :slight_smile:

dann hast sowieso einen Fehler oder das ist so eine IF-Wurst - die kann sowieso niemand mehr überblicken - nicht mal mehr du.

Da ist was faul.
Restlliches Post von mir hast auch gelesen?

(deleted)

Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :slight_smile:

Der von Arduino benutzte Code Formatierer ist fein einstellbar.

In der C/C++ Welt haben sich 2 Formatierungsstile quasi durchgesetzt.

  1. K&R
  2. Allman

K&R ist die default Einstellung.
Du verwendest eher Allman

Suche die Datei formatter.conf, diese liegt bei mir in Laufwerk:\Programme\arduino\lib
Füge folgende Zeile hinzu

style=allman

kgbrus:
Ich verzweifle immer an der Stelle, wenn ich den "delay" Befehl durch "Millis" ersetzen will.

Ev hilft es mir ja, wenn mir jemand von euch sagt, was an meinem Code falsch ist.

Zum einrücken war schion gesagt ....
Dein Problem ist nicht millis().

Du musst Dir den Status des PIN merken und das der erst in den Ausgangszustand (LOW) muss, bevor wieder neu ausgelöst wird.

if (!LSBG1State && digitalRead (LSBG1)) // Abfrage ob Zug auf Gleis 1 steht.
{
  LSBG1State = HIGH;
  digitalWrite (W1G, HIGH);
  RELAIS1G_timestore = millis();
}
if (!digitalRead (LSBG1)  // Wenn kein Zug auf dem Gleis:
{
LSBG1State = LOW;  // Status zurücksetzen
}

if (millis() - RELAIS1G_timestore > 1000) //Schaltzeit Relais 1 Sek.
{
digitalWrite (W1G, LOW);
  W1GState = LOW;
}

Moin,

Peter-CAD-HST:
ungetestet

LSBG1State = digitalRead(LSBG1);  

if (LSBG1State == HIGH &&  digitalRead(LSBG1) == LOW)

Das kann nicht.
Ich denke, Du wolltest W1G oder W1GState verwenden.
if (LSBG1State == HIGH && W1G == LOW)

Ich habe das absichtlich nicht so gemacht, weil der Code nicht vollständig und nicht klar ist wo was zu welchem Zweck verwendet wird...

Der STM32F103 kann mittels Arduino-IDE programmiert werden, wird aber von STMicroelectronics hergestellt. Dieses Forum finanziert sich durch den Verkauf von Arduinos und thematisiert folglich diese, weshalb genau genommen Fragen zum STM32F103 hier fehl am Platze sind. Unser Moderator ist aber glücklicherweise großzügig und läßt auch Fragen zu Nicht-Arduinos zu. Damit er nicht aufgeschreckt wird, haben wir Dich schon mal über Deinen kleinen Irrtum aufgeklärt.

Deine Frage hat aber eigentlich mit Deiner Hardware nichts zu tun, auf einem UNO wäre das nicht anders.

Spekulativ hat Deine Frage auch nur am Rande mit millis zu tun, denn grundsätzlich sieht das bei Dir richtig aus. Eher geht es um die Auswertung von sich ändernden Zuständen, also Flankenerkennung.

Möglicherweise findest Du die Bibliothek MobaTools hilfreich.

einen hab ich noch.
Imho ruft so ein Weichenantrieb regelrecht nach OOP oder will man die millis für jeden einzelne Weiche imm wieder manuell neu anlegen?

so zum Anfangen, mal nur die Weiche in OOP und die Gleisrückmeldung noch alt:

kompiliert, aber ungetestet

class Antrieb
{
  private:
    const byte pin;
    uint32_t previousMillis;

  public:
    Antrieb(byte pin) : pin(pin) {}
    void begin() {                      // einmal im Setup aufrufen
      pinMode(pin, OUTPUT);
    }
    void pulse()                        // wenn man schalten will
    {
      digitalWrite(pin, HIGH);
      previousMillis = millis();
    }
    void run()                          // laufend im loop aufrufen, damit sich der Magnetartikel auch wieder abschaltet
    {
      if (digitalRead(pin) == HIGH && millis() - previousMillis > 1000)
      {
        digitalWrite(pin, LOW);
      }
    }
};

//Weichen Antriebe anlegen und Pins zuordnen
Antrieb w1g(3);
Antrieb w1b(4);

// old style Gleisrückmeldungen:
const byte LSBG1 = 10;
byte previousLSBG1State;                         

void setup() {
  // put your setup code here, to run once:
  w1g.begin();
  w1b.begin();
}

void loop() {
  // Logik zum "Einschalten" .... 

  // gleis schaltet von frei auf besetzt
  
  byte LSBG1State = digitalRead(LSBG1);
  if (LSBG1State == HIGH && previousLSBG1State == LOW)
  {
    w1g.pulse();
    previousLSBG1State == LSBG1State;
  }
  if (LSBG1State == LOW && previousLSBG1State == HIGH);
  {
    // beim Verlassen was anderes tun
    previousLSBG1State == LSBG1State;
  }
  
  //usw

  // alle Weichenantriebe aufrufen - vieleicht ist einer zum abschalten...
  w1g.run();
  w1b.run();
}
1 Like

Da würde sich ein Blick ins Tutorial Von delay bis zur Methode von Rentner lohnen.

Gruß Tommy

@ all vielen Dank, genau die Art von Hilfe hab ich mir erwartet, ich dachte die ganze Zeit das das am milis Befehl liegt, da der Ablauf mit dem delay Befehl funktioniert. Der Fehler liegt woanders.

Das Programm soll ein freies Gleis im Schattenbahnhof suchen (LSBG1) ist eine Lichtschranke, die anzeigt das das Gleis besetzt ist, oder wenn alle Gleise besetzt sind den einfahrenden Zug am SBH vorbei leiten. Deshalb wird LSBG1 in dem Zusammenhang sich nicht ändern.. Dann muss ich mal gucken wie ich das löse.
Das hat mir aber schon viel weiter geholfen.

@combie style alleman hab ich eingefügt, ist jetzt besser.

@noiaska: Das sind keine Weichenantriebe, wie zB beim Märklin C Gleis. Das sind Märklin M Gleise. Hier wird einfach eine Spule auf Masse vom Gleis geschaltet. Die schalte ich über ein Relais.
W1A bedeutet "Weiche 1 auf abbiegen" schalten. W1G bedeutet "Weiche 1 auf geradeaus" schalten usw.
Wie wäre dein anderer Ansatz?

In deinem letzten Post gehst du von Weichenantrieben aus, die man Digital ansprechen kann?

@agumue Danke das schaue ich mir mal genauer an.
@my_xy_project: Danke für den Code, könnte schon die Lösung sein.

Vielen Dank für die Hilfe

Hier noch der Code:

Sorry beim ersten Versuch war der Post zu lang. (Limit 9000 Zeichen) beim 2ten mal kam die Meldung ich muss 5 Minuten warten bis zum nächsten Post..

/* 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
                Version 7.0 Delay Befehl durch millies 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;



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;


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äht. 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
    {
      digitalWrite (WHauptA, HIGH);
      RELAISHauptA_timestore = millis();
    }
    if (millis() - RELAISHauptA_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptA, LOW);
      WHauptAState = LOW;
    }

    else
      //    if (LSBG1State == 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;
    }


    LSBG1State = digitalRead(LSBG1);  // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      digitalWrite (W1G, HIGH);
      RELAIS1G_timestore = millis();
    }

    if (millis() - RELAIS1G_timestore > 1000 ) //Schaltzeit Relais 1 Sek.
    {
      digitalWrite(W1G, LOW);
      W1GState = LOW;
    }

    if (LSBG1State == LOW)
    {
      digitalWrite (W1A, HIGH);
      RELAIS1A_timestore = millis();
    }

    if (millis() - RELAIS1A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W1A, LOW);
      W1AState = LOW;
    }

    LSBG2State = digitalRead(LSBG2);  // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      digitalWrite (W2G, HIGH);
      RELAIS2G_timestore = millis();
    }

    if (millis() - RELAIS2G_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W2G, LOW);
      W2GState = LOW;
    }

    if (LSBG2State == LOW)
    {
      digitalWrite (W2A, HIGH);
      RELAIS2A_timestore = millis();
    }

    if (millis() - RELAIS2A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W2A, LOW);
      W2AState = LOW;
    }

    LSBG3State = digitalRead(LSBG3);   // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      digitalWrite (W3G, HIGH);
      RELAIS3G_timestore = millis();
    }

    if (millis() - RELAIS3G_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W3G, LOW);
      W3GState = LOW;
    }

    if (LSBG3State == LOW)
    {
      digitalWrite (W3A, HIGH);
      RELAIS3A_timestore = millis();
    }

    if (millis() - RELAIS3A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W3A, LOW);
      W3AState = LOW;
    }

    LSBG4State = digitalRead(LSBG4);   // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      digitalWrite (W4G, HIGH);
      RELAIS4G_timestore = millis();
    }

    if (millis() - RELAIS4G_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W4G, LOW);
      W4GState = LOW;
    }

    if (LSBG4State == LOW)
    {
      digitalWrite (W4A, HIGH);
      RELAIS4A_timestore = millis();
    }

    if (millis() - RELAIS4A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W4A, LOW);
      W4AState = LOW;
    }

    LSBG5State = digitalRead(LSBG5);

  }


}

In deinem letzten Post gehst du von Weichenantrieben aus, die man Digital ansprechen kann?

nein, schau dir das noch mal an.

In der Klasse ist ein ganz normaler digitialWrite HIGH und ein digitalWrite LOW fürs abschalten. So wie in deinem Code für einen Antrieb auch.

Die Klasse beschreibt wie ein Antrieb funktioniert: Wir brauchen etwas fürs Setup, etwas zum Schalten und die Überwachung, dass nach 1 Sekunde der Magnetartikel wieder abschaltet. Ganz das gleiche wie bei dir auch.

Der Unterschied ist, ich brauche für 2 (oder 10 wie bei dir) Weichenantriebe nur einmal definieren was so ein Antrieb kann und wie er nach Zeitablauf wieder abschaltet.

Nach der Klassendefinition, lege ich zwei konkrete Objekte an. Dabei gibts einen Namen für den Antrieb und die Zuordnung von einem Pin.

Bei dir steht der Code fürs abschalten 10 mal drinnen - für jeden einzelnen Weichenantrieb. Das bläht den Code auf und kann zu Copy-Paste fehlern führen.

@noiaska, ahh verstanden. Ich bin absoluter Neuling in C++ und hab mit Klassen noch nichts gemacht, das muss ich mich erst mal einlesen. BZw ich denke das ist noch etwas zu früh für mich.
Prinzipiell hast du aber Recht, das deine Lösung die bessere ist.

Hier ist der Code mit dem delay Befehl, der macht genau, was er soll:

/* 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
*/
// 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;


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;

// delay zeit um zwischenräume zwischen Wagons abzufangen
unsigned long LSBG1_timestore_akt = 0;
unsigned long LSBG1_timestore_alt = 0;
unsigned long LSBG1_delay (3000);
unsigned long LSBG1High_timestore_akt = 0;
unsigned long LSBG1High_timestore_alt = 0;
unsigned long LSBG2_timestore_akt = 0;
unsigned long LSBG2_timestore_alt = 0;
unsigned long LSBG2_delay (3000);
unsigned long LSBG2High_timestore_akt = 0;
unsigned long LSBG2High_timestore_alt = 0;
unsigned long LSBG3_timestore_akt = 0;
unsigned long LSBG3_timestore_alt = 0;
unsigned long LSBG3_delay (3000);
unsigned long LSBG3High_timestore_akt = 0;
unsigned long LSBG3High_timestore_alt = 0;
unsigned long LSBG4_timestore_akt = 0;
unsigned long LSBG4_timestore_alt = 0;
unsigned long LSBG4_delay (3000);
unsigned long LSBG4High_timestore_akt = 0;
unsigned long LSBG4High_timestore_alt = 0;
unsigned long LSBG5_timestore_akt = 0;
unsigned long LSBG5_timestore_alt = 0;
unsigned long LSBG5_delay (3000);
unsigned long LSBG5High_timestore_akt = 0;
unsigned long LSBG5High_timestore_alt = 0;








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äht. 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
    {
      digitalWrite (WHauptA, HIGH);
      delay(1000);
      digitalWrite (WHauptA, LOW);
    }
    else
      //    if (LSBG1State == LOW || LSBG2State == LOW || LSBG3State == LOW || LSBG4State == LOW || LSBG5State == LOW)  // Abfrage ob alle Gleise besetzt sind                                          // nicht alle Gleise sind besetzt
    {
      digitalWrite (WHauptG, HIGH);
      delay(1000);
      digitalWrite (WHauptG, LOW);
    }

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


}

Damit ich das richtig verstehe, ich kann den delay Befehl nicht so einfach als Funktion durch Millies ersetzten? Da muss ich andere Bedungen schaffen?