Andreaskreuz Blinksteuerung mittels Arduino

Andreaskreuz Blinksteuerung mittels Arduino

Auf der Kinderanlage möchte ich einen Bahnübergang mit Andreaskreuz darzustellen. Daher war ich auf der Suche nach einer einfachen Möglichkeit die LED´s in den Andreaskreuzen abwechselnd zum Blinken zu bringen. Natürlich gibt es für diese Aufgabe fertige Blinkelektronik auf dem Markt, allerdings habe ich bereits zur Weichensteuerung ein Arduino im Einsatz (Hier geht es zum Bericht). Also lag es nahe mit Hilfe des vorhandenen Arduinos diese Aufgabe zu erledigen.

Grundsätzlicher Aufbau

Für den Bahnübergang verwende ich Andreaskreuzbausätze von Viessmann (erhältlich bei Conrad oder Völkner). Wie man die Andreaskreuze genau zusammenbaut, werde ich in einem extra Bericht für euch festhalten. Aber nun zurück zu Blinklichtsteuerung. Durch Betätigung eines Drucktaster sollen die LED´s am Bahnübergang beginnen zu leuchten und sobald der Taster ein weiters mal gedrückt wird, wieder erlöschen. Natürlich könnte man die Andreaskreuze auch vom vorbeifahrenden Zug per Kontaktgleis oder ähnlichem auslösen lassen, aber das war nicht meine Ziel (..wäre aber auch mit dem Arduino Machbar).

Verkabelung:

Die grundsätzliche Verkabelung der Andreaskreuz Blinksteuerung sieht wie folgt aus:

Kommen wir nun zum Eigentlichen Sketch:

Das hier erklärte Arduino Sketch umfasst nur die Funktionalität der Andreaskreuz Blinksteuerung, sozusagen als stand-alone Version.

Ihr könnt das entsprechende Sketch hier herunterladen:
—> Andreaskreuz Blinksteuerung stand-alone

Für mein Stellpult habe ich das ganze natürlich in das bereits vorgestellte Weichensteuerung Sketch integriert (siehe Arduino Weichensteuerung), als Vollversion….

Ihr könnt das  entsprechende Sketch hier herunterladen
—> Andreaskreuz Blinksteuerung  + Weichensteuerung

Im Kopf des Sketch werden zunächst die Input (Drucktaster) und Output (Andreaskreuz LEDs) PINs festgelegt. Damit das Sketch korrekt abläuft kann, müssen noch einige Variablen und Initialwert definiert werden.
Mit der variable Crossing_tiLightInterval kann die Blinkdauer individuell eingestellt werden. Der Wert ist immer in milliseconden, somit in unserem Beispiel 500ms (500ms LED ON / 500ms LED OFF)

//##########################  Crossing control  ######################################

// **********************Crossing light PIN********************

//Definition of input PIN for Crossing light control pushbutton
const int  Button_inCrossing = 2;                        // the number of the crossing light pushbutton pin

// Definition of output PINs for Crossing light LEDs:
const int Led_outCrossing1 =  10;                       // the number of the Crossing light 1 LED pin
const int Led_outCrossing2 =  11;                       // the number of the Crossing light 1 LED pin

// **********************Variables for Crossing light LED status********************
int Led_stCrossing1 = LOW;                            // variable for Crossing light 1 LED status
int Led_stCrossing2 = LOW;                            // variable for Crossing light 2 LED status

// **********************Variables for Crossing light pushbutton status********************
int Button_stCrossing = 0;                            // variable for reading the Crossing pushbutton status
int Blink_stCrossing = 1;                             // Variable for Crossing Blinking status
int Button_stCrossing_Previous = 0;                   // variable for storing last Crossing pushbutton satus

// **********************Variables for timers********************
unsigned long Crossing_tiCurrentMillis = 0;           // variable for reading the current millis value
unsigned long Crossing_tiPreviousMillis = 0;          // variable to store the previous millis value
unsigned long Crossing_tiLightInterval = 500;         // Interval timer for Crossing light flashing

Im „void  setup ()“ wird die Funktion der einzelnen PIN´s, ob es sich um einen Input oder Output handelt, genau definiert. Des Weiteren ist noch wichtig zu erwähnen, dass ich für den Input immer den internen Pull Up Widerstand des Atmega chip verwende. Dadurch sind alle Eingangssignale invertiert d.h. Taster gedrückt = Low und Taster nicht gedrückt = High .

void setup() {

 //##########################  Crossing control  ######################################

  //*******************Crossing PIN Mode******************

  // initialize the Crossing Light pushbutton pin as an input:
  pinMode(Button_inCrossing, INPUT_PULLUP);

  // initialize the Crossing Light LED pins as an output:
  pinMode(Led_outCrossing1, OUTPUT);
  pinMode(Led_outCrossing2, OUTPUT);
}

Im „void loop ()“ steht nun der eigentliche Programmcode für die Steuerung. Zunächst wird ständig mit Hilfe des Befehls „millis()“ die aktuelle Einschaltdauer der Arduinos and die variable Crossing_tiCurrentMillis übergeben. Diese Zeitabfrage ist wichtig um das Blinken der LEDs zu erreichen.
Mittels If Abfrage wird geprüft ob ein Blinken nun gewünscht ist oder nicht. Wenn Blink_stCrossing== HIGH ist, wird das Blinken Aktiviert. Die zweite If Abfrage sorgt dafür, das nach Ablaufen der Blinkdauer (Crossing_tiLightInterval) die LEDs ein bzw. wieder ausgeschaltet werden. Wenn kein Blinken gewünscht wird, sind die LEDs abgeschaltet (else Pfad)

void loop() {
    //##########################  Crossing control  ######################################
  
  // ########### Crossing LED control: ###########
 
  Crossing_tiCurrentMillis = millis();                                                            // Write actual time in crossing_tiCurrentMillis

  if ( Blink_stCrossing == HIGH) {                                                                // check if Blink_stCrossing is active, if yes activate crossing LEDs
    if (Crossing_tiCurrentMillis - Crossing_tiPreviousMillis > Crossing_tiLightInterval) {        // check if delay time to switch other LEDs is elapsed
      Crossing_tiPreviousMillis = Crossing_tiCurrentMillis;                                       // write actual time to Crossing_tiPreviousMillis
      if (Led_stCrossing1 == LOW) {                                                               // check if LED status is LOW
        Led_stCrossing1 = HIGH;                                                                   // Set Led_stCrossing1 to High
        Led_stCrossing2 = LOW;                                                                    // Set Led_stCrossing2 to low
      } else {
        Led_stCrossing1 = LOW;                                                                    // Set Led_stCrossing1 to low
        Led_stCrossing2 = HIGH;                                                                   // Set Led_stCrossing2 to High
      }
      digitalWrite(Led_outCrossing1, Led_stCrossing1);                                            // Switch LED Crossing 1 corresponding to Led_stCrossing1)
      digitalWrite(Led_outCrossing2, Led_stCrossing2);                                            // Switch LED Crossing 2 corresponding to Led_stCrossing2)
    }
  } else {
    digitalWrite(Led_outCrossing1, LOW);                                                          // Switch LED Crossing 1 off                                                      
    digitalWrite(Led_outCrossing2, LOW);                                                          // Switch LED Crossing 2 off  
  }

  // ########### Check Crossing pushbutton status for Flip Flop: ###########
  Button_stCrossing = digitalRead (Button_inCrossing);                                           // Check crossing pushbutton Status
  if (Button_stCrossing_Previous != Button_stCrossing) {                                         // Check if crossing pushbutton Status has changed
    if (Button_stCrossing == HIGH)                                                               // If pushbutton was activated, Blink_stCrossing will be changed
    {

      Blink_stCrossing = !Blink_stCrossing;                 

    }
    Button_stCrossing_Previous = Button_stCrossing;                                               // Actual Crossing pushbutton Status is stored
    delay (200);                                                                                  // Debouncing for the pushbutton to avoid toggle of signal   
  }
}