int AUF1 = 23;                 // Einlesekanal Schranke Auf (BOM1)
int ZU1 = 22;                  // Einlesekanal Schranke ZU (BOM1)
int AUF2 = 3;                 // Einlesekanal Schranke Auf (BOM2)
int ZU2 = 2;                  // Einlesekanal Schranke ZU (BOM2)
int AUF3 = 25;                 // Einlesekanal Schranke Auf (BOM3)
int ZU3 = 24;                  // Einlesekanal Schranke ZU (BOM3)
int AUF4 = 21;                 // Einlesekanal Schranke Auf (BOM4)
int ZU4 = 20;                  // Einlesekanal Schranke ZU (BOM4)
int AUF5 = 27;                 // Einlesekanal Schranke Auf (BOM5)
int ZU5 = 26;                  // Einlesekanal Schranke ZU (BOM5)
int AUF6 = 29;                 // Einlesekanal Schranke Auf (BOM6)
int ZU6 = 28;                  // Einlesekanal Schranke ZU (BOM6)

int Laufzeit = 5000;
int laststate = LOW;
int laststate1 = LOW;
int laststate2 = LOW;
int laststate3 = LOW;
int laststate4 = LOW;
int laststate5 = LOW;
int laststate6 = LOW;
int laststate7 = LOW;
int laststate8 = LOW;
int laststate9 = LOW;
int laststate10 = LOW;
int laststate11 = LOW;

long premillis = 100;
long premillis1 = 100;
long premillis2 = 100;
long premillis3 = 100;
long premillis4 = 100;
long premillis5 = 100;
long premillis6 = 100;
long premillis7 = 100;
long premillis8 = 100;
long premillis9 = 100;
long premillis10 = 100;
long premillis11 = 100;
void setup() {

  pinMode(AUF1, INPUT_PULLUP);
  pinMode(ZU1, INPUT_PULLUP);
  pinMode(AUF2, INPUT_PULLUP);
  pinMode(ZU2, INPUT_PULLUP);
  pinMode(AUF3, INPUT_PULLUP);
  pinMode(ZU3, INPUT_PULLUP);
  pinMode(AUF4, INPUT_PULLUP);
  pinMode(ZU4, INPUT_PULLUP);
  pinMode(AUF5, INPUT_PULLUP);
  pinMode(ZU5, INPUT_PULLUP);
  pinMode(AUF6, INPUT_PULLUP);
  pinMode(ZU6, INPUT_PULLUP);
  pinMode(30, OUTPUT);           //Auf BOM 1
  pinMode(31, OUTPUT);           //Zu BOM 1
  pinMode(32, OUTPUT);           //Lauf BOM 1
  pinMode(4, OUTPUT);           //Auf BOM 2
  pinMode(5, OUTPUT);           //Zu BOM 2
  pinMode(6, OUTPUT);           //Lauf BOM 2
  pinMode(33, OUTPUT);           //Auf BOM 3
  pinMode(34, OUTPUT);           //Zu BOM 3
  pinMode(35, OUTPUT);           //Lauf BOM 3
  pinMode(36, OUTPUT);           //Auf BOM 4
  pinMode(37, OUTPUT);           //Zu BOM 4
  pinMode(38, OUTPUT);           //Lauf BOM 4
  pinMode(39, OUTPUT);           //Auf BOM 5
  pinMode(40, OUTPUT);           //Zu BOM 5
  pinMode(41, OUTPUT);           //Lauf BOM 5
  pinMode(14, OUTPUT);           //Auf BOM 6
  pinMode(15, OUTPUT);           //Zu BOM 6
  pinMode(16, OUTPUT);           //Lauf BOM 6

  digitalWrite(30, HIGH);           //Auf BOM 1
  digitalWrite(4, HIGH);           //Auf BOM 2
  digitalWrite(33, HIGH);           //Auf BOM 3
  digitalWrite(36, HIGH);           //Auf BOM 4
  digitalWrite(39, HIGH);           //Auf BOM 5
  digitalWrite(14, HIGH);           //Auf BOM 6

}

void loop() {

  int AUF10 = digitalRead(AUF1);
  int ZU10  = digitalRead(ZU1);
  int AUF20 = digitalRead(AUF2);
  int ZU20  = digitalRead(ZU2);
  int AUF30 = digitalRead(AUF3);
  int ZU30  = digitalRead(ZU3);
  int AUF40 = digitalRead(AUF4);
  int ZU40  = digitalRead(ZU4);
  int AUF50 = digitalRead(AUF5);
  int ZU50  = digitalRead(ZU5);
  int AUF60 = digitalRead(AUF6);
  int ZU60  = digitalRead(ZU6);

//--------------BOM1-------------------------------------
if( AUF10 == HIGH && laststate == LOW){
  if (AUF10 == HIGH)  {
    digitalWrite(32, HIGH);        //Schrankenlauf
    digitalWrite(30, LOW);
    digitalWrite(31, LOW);
    auf_1();
  }
}

if ( ZU10 == HIGH && laststate1 == LOW){
  if (ZU10 == HIGH) {
    digitalWrite(32, HIGH);         //Schrankenlauf
    digitalWrite(30, LOW);
    digitalWrite(31, LOW);
    zu_1();
  }
}
//----------------BOM2--------------------------------------------------
if( AUF20 == HIGH && laststate2 == LOW){
  if (AUF20 == HIGH)  {
    digitalWrite(6, HIGH);        //Schrankenlauf
    digitalWrite(5, LOW);
    digitalWrite(4, LOW);
    auf_2();
  }
}

if ( ZU20 == HIGH && laststate3 == LOW){
  if (ZU20 == HIGH) {
    digitalWrite(6, HIGH);        //Schrankenlauf
    digitalWrite(5, LOW);
    digitalWrite(4, LOW);
    zu_2();
  }
}
//----------------BOM3----------------------------------------------
if( AUF30 == HIGH && laststate4 == LOW){
  if (AUF30 == HIGH)  {
    digitalWrite(35, HIGH);        //Schrankenlauf
    digitalWrite(33, LOW);
    digitalWrite(34, LOW);
    auf_3();
  }
}

if ( ZU30 == HIGH && laststate5 == LOW){
  if (ZU30 == HIGH) {
    digitalWrite(35, HIGH);        //Schrankenlauf
    digitalWrite(33, LOW);
    digitalWrite(34, LOW);
    zu_3();
  }
}
//----------------BOM4------------------------------------------
if( AUF40 == HIGH && laststate6 == LOW){
  if (AUF40 == HIGH)  {
    digitalWrite(38, HIGH);        //Schrankenlauf
    digitalWrite(37, LOW);
    digitalWrite(36, LOW);
    auf_4();
  }
}

if ( ZU40 == HIGH && laststate7 == LOW){
  if (ZU40 == HIGH) {
    digitalWrite(38, HIGH);        //Schrankenlauf
    digitalWrite(37, LOW);
    digitalWrite(36, LOW);
    zu_4();
  }
}
//----------------BOM5----------------------------------------------------
if( AUF50 == HIGH && laststate8 == LOW){
  if (AUF50 == HIGH)  {
    digitalWrite(41, HIGH);        //Schrankenlauf
    digitalWrite(39, LOW);
    digitalWrite(40, LOW);
    auf_5();
  }
}

if ( ZU50 == HIGH && laststate9 == LOW){
  if (ZU50 == HIGH) {
    digitalWrite(41, HIGH);        //Schrankenlauf
    digitalWrite(39, LOW);
    digitalWrite(40, LOW);
    zu_5();
  }
}
//-----------------BOM6--------------------------------------------
if( AUF60 == HIGH && laststate10 == LOW){
  if (AUF60 == HIGH)  {
    digitalWrite(16, HIGH);         //Schrankenlauf
    digitalWrite(14, LOW);
    digitalWrite(15, LOW);
    auf_6();
  }
}

if ( ZU60 == HIGH && laststate11 == LOW){
  if (ZU60 == HIGH) {
    digitalWrite(16, HIGH);         //Schrankenlauf
    digitalWrite(14, LOW);
    digitalWrite(15, LOW);
    zu_6();
  }
}






}
void auf_1(){
if (millis()- premillis >= Laufzeit){
      digitalWrite(30, HIGH);         //Auf
      digitalWrite(31, LOW);
      digitalWrite(32, LOW);
      premillis = millis();
      laststate = LOW;
}
}
void zu_1(){
if (millis()- premillis1 >= Laufzeit){
      digitalWrite(31, HIGH);         //Zu
      digitalWrite(30, LOW);
      digitalWrite(32, LOW);
        premillis1 = millis();
        laststate1 = LOW;
}
}
  void auf_2(){
if (millis()- premillis2 >= Laufzeit){
      digitalWrite(4, HIGH);         //Auf
      digitalWrite(5, LOW);
      digitalWrite(6, LOW);
         premillis2 = millis();
         laststate2 = LOW;
}
}
void zu_2(){
if (millis()- premillis3 >= Laufzeit){
      digitalWrite(5, HIGH);         //Zu
      digitalWrite(6, LOW);
      digitalWrite(4, LOW);
   premillis3 = millis();
   laststate3 = LOW;
}
}
void auf_3(){
if (millis()- premillis4 >= Laufzeit){
      digitalWrite(33, HIGH);         //Auf
      digitalWrite(34, LOW);
      digitalWrite(35, LOW);
   premillis4 = millis();
   laststate4 = LOW;
}
}
void zu_3(){
if (millis()- premillis5 >= Laufzeit){
      digitalWrite(34, HIGH);         //Zu
      digitalWrite(33, LOW);
      digitalWrite(35, LOW);
   premillis5 = millis();
   laststate5 = LOW;
}
}
void auf_4(){
if (millis()- premillis6 >= Laufzeit){
      digitalWrite(36, HIGH);         //Auf
      digitalWrite(37, LOW);
      digitalWrite(38, LOW);
         premillis6 = millis();
         laststate6 = LOW;
}
}
void zu_4(){
if (millis()- premillis7 >= Laufzeit){
      digitalWrite(37, HIGH);         //Zu
      digitalWrite(36, LOW);
      digitalWrite(38, LOW);
   premillis7 = millis();
   laststate7 = LOW;
}
}
void auf_5(){
if (millis()- premillis8 >= Laufzeit){
      digitalWrite(39, HIGH);         //Auf
      digitalWrite(40, LOW);
      digitalWrite(41, LOW);
         premillis8 = millis();
         laststate8 = LOW;
}
}
void zu_5(){
if (millis()- premillis9 >= Laufzeit){
      digitalWrite(40, HIGH);         //Zu
      digitalWrite(39, LOW);
      digitalWrite(41, LOW);
   premillis9 = millis();
   laststate9 = LOW;
}
}
void auf_6(){
if (millis()- premillis10 >= Laufzeit){
      digitalWrite(14, HIGH);         //Auf
      digitalWrite(15, LOW);
      digitalWrite(16, LOW);
         premillis10 = millis();
         laststate10 = LOW;
}
}
void zu_6(){
if (millis()- premillis11 >= Laufzeit){
      digitalWrite(15, HIGH);         //Zu
      digitalWrite(16, LOW);
      digitalWrite(14, LOW);
   premillis11 = millis();
   laststate11 = LOW;
}
}