//Initialisierung Helligkeitssensor
char Helligkeitssensor1 = A0;
char Helligkeitssensor2 = A1;
char Helligkeitssensor3 = A2;
char Helligkeitssensor4 = A3;
char Helligkeitssensor5 = A4;
char Helligkeitssensor6 = A5;

//Initialisierung LEDs
char LED1 = 9;
char LED2 = 8;
char LED3 = 7;
char LED4 = 6;
char LED5 = 5;
char LED6 = 4;

//Initialisierung Hilfsvariablen
char x1 = 0;
char x2 = 0;
char x3 = 0;
char x4 = 0;
char x5 = 0;
char x6 = 0;

char Sensor_Schritt1= 0;
char Sensor_Schritt2= 0;
char Sensor_Schritt3= 0;
char Sensor_Schritt4= 0;
char Sensor_Schritt5= 0;
char Sensor_Schritt6= 0;

char LED_war_H = 0;
char LED_war_H_2 = 0;
char LED_war_H_3 = 0;
char LED_war_H_4 = 0;
char LED_war_H_5 = 0;
char LED_war_H_6 = 0;

char LED_ist_wieder_L = 0;
char LED_ist_wieder_L_2 = 0;
char LED_ist_wieder_L_3  = 0;
char LED_ist_wieder_L_4 = 0;
char LED_ist_wieder_L_5 = 0;
char LED_ist_wieder_L_6 = 0;

char Schritt_Reihenfolge = 0;

char Erster_Durchlauf = 0;
char Runde2 = 0;

char Schritt1_vorgekommen  = 0;
char Schritt2_vorgekommen  = 0;
char Schritt3_vorgekommen  = 0;
char Schritt4_vorgekommen  = 0;
char Schritt5_vorgekommen  = 0;
char Schritt6_vorgekommen  = 0;

float LED_Schritt[6]= {0,0,0,0,0,0};
float pruefer_sensor[6] = {0,0,0,0,0,0};

int Sensor1_Zustand = 0;
int Sensor2_Zustand = 0;
int Sensor3_Zustand = 0;
int Sensor4_Zustand = 0;
int Sensor5_Zustand = 0;
int Sensor6_Zustand = 0;

char step1_immer_noch_H = 0;
char step2_immer_noch_H = 0;
char step3_immer_noch_H = 0;
char step4_immer_noch_H = 0;
char step5_immer_noch_H = 0;
char step6_immer_noch_H = 0;
    
 void setup() {
pinMode(Helligkeitssensor1,INPUT); 
pinMode(Helligkeitssensor2,INPUT); 
pinMode(Helligkeitssensor3,INPUT); 
pinMode(Helligkeitssensor4,INPUT); 
pinMode(Helligkeitssensor5,INPUT); 
pinMode(Helligkeitssensor6,INPUT); 

pinMode(LED1,OUTPUT); 
pinMode(LED2,OUTPUT); 
pinMode(LED3,OUTPUT); 
pinMode(LED4,OUTPUT); 
pinMode(LED5,OUTPUT);
pinMode(LED6,OUTPUT);

 }
void loop() 
{
     
    float LEDs[6] = {LED1,LED2,LED3,LED4,LED5,LED6};
    float Sensoren[6] = {Helligkeitssensor1,Helligkeitssensor2,Helligkeitssensor3,Helligkeitssensor4,Helligkeitssensor5,Helligkeitssensor6};
    float Sensoren_variable[6] = {Helligkeitssensor1,Helligkeitssensor2,Helligkeitssensor3,Helligkeitssensor4,Helligkeitssensor5,Helligkeitssensor6};


    Sensoren[0] = analogRead(Helligkeitssensor1);
    Sensoren[1] = analogRead(Helligkeitssensor2);
    Sensoren[2] = analogRead(Helligkeitssensor3);
    Sensoren[3] = analogRead(Helligkeitssensor4);
    Sensoren[4] = analogRead(Helligkeitssensor5);
    Sensoren[5] = analogRead(Helligkeitssensor6);
  
   

  /*if(Sensoren[0]>= 1015){
    digitalWrite(LEDs[0],HIGH);
      //Serial.println("2");
    }
    */
//Schritt1------------------------------------------------------------------------------------------------------------     
if(((Sensoren[0] <= 0)||(Sensoren[1] <= 0)||(Sensoren[2] <= 0)||(Sensoren[3] <= 0)||(Sensoren[4] <= 0)||(Sensoren[5] <= 0)) &&((Schritt_Reihenfolge == 0)||(Schritt_Reihenfolge == 6))){     //Wenn ein Sensor aktiviert wird und dieser Schritt an der Reihe ist
        Serial.println("1");
  for(int x = 0; x < 6 ; x ++){  
       
    if ((LED_Schritt[0] == 0) && (Sensoren[x] <= 3)&&(pruefer_sensor[x]== 0)){ //Wenn die Nummer des x mit dem aktivierten Sensor übereinstimmt und sensor nicht bereits in Schritten vorher HIGH war

      Sensor_Schritt1= Sensoren_variable[x];   //aktivierter Sensor wird diesem Schritt zugewiesen
      LED_Schritt[0] = LEDs[x];                //dazugehörige LED des Sensors wird diesem Schritt zugewiesen
      pruefer_sensor[x] = 1;                   
      x1 = x;                                  //die Nummer des Sensors wird x zugewiesen
      Schritt_Reihenfolge = 1;                 //wird um 1 erhöht dass es in den Schritt2 gehen kann
      Schritt1_vorgekommen  = 1;               //sichert ab das dieser Schritt vorkam

      if(Runde2 == 1){                         //Wenn die erste Runde durch ist
       Erster_Durchlauf = 1;
       }

    } 
  }
}

Sensor1_Zustand = analogRead(Sensor_Schritt1);       //Zustand des Sensors wird ausgelesn

if((Sensor1_Zustand <= 0)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L == 1))||(Erster_Durchlauf == 0))){       //wenn alle anderen LEDs Low sind oder es der erste Durchlauf ist und der Sensor von Schritt1 HIGH ist
  digitalWrite(LED_Schritt[0],HIGH);
  if(Schritt1_vorgekommen  == 1){  
     LED_ist_wieder_L = 0;
     step1_immer_noch_H = 1;
   }
}

if(Sensor1_Zustand > 1){
  digitalWrite(LED_Schritt[0],LOW);
  pruefer_sensor[x1] = 0;
  LED_ist_wieder_L = 1;
  //löschen
  LED_Schritt[0] = 0;
  Sensor_Schritt1= 0;
  Sensor1_Zustand = 0;
  Schritt1_vorgekommen  = 0;
  step1_immer_noch_H = 0;
    Serial.println("2");
}


//Ende Schritt 1 ---------------------------------------------------------------------------------------------------------


//Schritt2 ---------------------------------------------------------------------------------------------------------------
if(((Sensoren[0] <= 0)||(Sensoren[1] <= 0)||(Sensoren[2] <= 0)||(Sensoren[3] <= 0)||(Sensoren[4] <= 0)||(Sensoren[5] <= 0))&&(Schritt_Reihenfolge == 1)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt

  for(int x = 0; x < 6 ; x ++){
   
    if ((Sensoren[x] <= 3)&&(pruefer_sensor[x] == 0)&&( LED_Schritt[1]== 0)){ 

          LED_Schritt[1]= LEDs[x];
          Sensor_Schritt2= Sensoren_variable[x]; 
          pruefer_sensor[x] = 1;
          Schritt_Reihenfolge = 2;
          x2 = x;
          Schritt2_vorgekommen  = 1;
         

    
    } 
  }
}

Sensor2_Zustand = analogRead(Sensor_Schritt2);

if((Sensor2_Zustand <= 0)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_2 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)){
  digitalWrite(LED_Schritt[1],HIGH);
  if(Schritt2_vorgekommen  == 1){
   LED_ist_wieder_L_2 = 0;
   step2_immer_noch_H = 1;
  }
}



if(Sensor2_Zustand > 1){
  digitalWrite(LED_Schritt[1],LOW);
  pruefer_sensor[x2] = 0;
  LED_ist_wieder_L_2 = 1;
  //löschen
  LED_Schritt[1] = 0;
  Sensor_Schritt2= 0;
  Sensor2_Zustand = 0;
  Schritt2_vorgekommen  = 0;
  step2_immer_noch_H = 0;
}


//Ende Schritt 2 ------------------------------------------------------------------------------------------------------------
//Schritt3 ---------------------------------------------------------------------------------------------------------------
if(((Sensoren[0] <= 0)||(Sensoren[1] <= 0)||(Sensoren[2] <= 0)||(Sensoren[3] <= 0)||(Sensoren[4] <= 0)||(Sensoren[5] <= 0)) &&(Schritt_Reihenfolge == 2)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt

  for(int x = 0; x < 6 ; x ++){
    
    if ((Sensoren[x] <= 3)&&(pruefer_sensor[x] == 0)&&(LED_Schritt[2] == 0)){ 
       
          LED_Schritt[2] = LEDs[x];
          Sensor_Schritt3= Sensoren_variable[x];  
          pruefer_sensor[x] = 1;
          Schritt_Reihenfolge = 3;
          x3 = x;
          Schritt3_vorgekommen  = 1;

    } 
  }
}

Sensor3_Zustand = analogRead(Sensor_Schritt3);

if((Sensor3_Zustand <= 0)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_3 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)){
  digitalWrite(LED_Schritt[2],HIGH);
  if(Schritt3_vorgekommen  == 1){
    LED_ist_wieder_L_3 = 0;
    step3_immer_noch_H = 1;
  }
}

if(Sensor3_Zustand > 1){
  digitalWrite(LED_Schritt[2],LOW);
   pruefer_sensor[x3] = 0;
   LED_ist_wieder_L_3 = 1;
  //löschen
  LED_Schritt[2] = 0;
  Sensor_Schritt3= 0;
  Sensor3_Zustand = 0;
  Schritt3_vorgekommen  = 0;
  step3_immer_noch_H = 0;
}



//Ende Schritt 3 ------------------------------------------------------------------------------------------------------------

//Schritt4 ---------------------------------------------------------------------------------------------------------------
if(((Sensoren[0] <= 0)||(Sensoren[1] <= 0)||(Sensoren[2] <= 0)||(Sensoren[3] <= 0)||(Sensoren[4] <= 0)||(Sensoren[5] <= 0)) &&(Schritt_Reihenfolge == 3)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt

  for(int x = 0; x < 6 ; x ++){
   
    if ((Sensoren[x] <= 3)&&(pruefer_sensor[x] == 0)&&(LED_Schritt[3] == 0)){ //zb 1

          LED_Schritt[3] = LEDs[x];
          Sensor_Schritt4= Sensoren_variable[x];  
          pruefer_sensor[x] = 1;
          Schritt_Reihenfolge = 4;
          x4 = x;
          Schritt4_vorgekommen  = 1;
      
    } 
  }
}
    
Sensor4_Zustand = analogRead(Sensor_Schritt4);

if((Sensor4_Zustand <= 0)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L_3 == 1)){
  digitalWrite(LED_Schritt[3],HIGH);
  if(Schritt4_vorgekommen  == 1){
    LED_ist_wieder_L_4 = 0;
    step4_immer_noch_H = 1;
  } 
}

if(Sensor4_Zustand > 1){
  digitalWrite(LED_Schritt[3],LOW);
   pruefer_sensor[x4] = 0;
    LED_ist_wieder_L_4 = 1;
  //löschen
  LED_Schritt[3] = 0;
  Sensor_Schritt4= 0;
  Sensor4_Zustand = 0;
  Schritt4_vorgekommen  = 0;
  step4_immer_noch_H = 0;
  }

//Ende Schritt 4 ------------------------------------------------------------------------------------------------------------


//Schritt5 ---------------------------------------------------------------------------------------------------------------
if(((Sensoren[0] <= 0)||(Sensoren[1] <= 0)||(Sensoren[2] <= 0)||(Sensoren[3] <= 0)||(Sensoren[4] <= 0)||(Sensoren[5] <= 0))&&(Schritt_Reihenfolge == 4)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt

  for(int x = 0; x < 6 ; x ++){
   
    if ((Sensoren[x] <= 3)&&(pruefer_sensor[x] == 0)&&(LED_Schritt[4] == 0)){ //zb 1

          LED_Schritt[4] = LEDs[x];
          Sensor_Schritt5= Sensoren_variable[x];  
          pruefer_sensor[x] = 1;
          Schritt_Reihenfolge = 5;
          x5 = x;
          Schritt5_vorgekommen  = 1;
        
            
      
    } 
  }
}
    
Sensor5_Zustand = analogRead(Sensor_Schritt5);

if((Sensor5_Zustand <= 0)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_4 == 1)){
  digitalWrite(LED_Schritt[4],HIGH);
  if(Schritt5_vorgekommen  == 1){
   LED_ist_wieder_L_5 = 0;
   step5_immer_noch_H = 1;
  }
}

if(Sensor5_Zustand > 1){
  digitalWrite(LED_Schritt[4],LOW);
  pruefer_sensor[x5] = 0;
  LED_ist_wieder_L_5 = 1;
  step5_immer_noch_H = 0;
  //löschen
  LED_Schritt[4] = 0;
  Sensor_Schritt5= 0;
  Sensor5_Zustand = 0;
  Schritt5_vorgekommen  = 0;
}

  
//Ende Schritt 5 ------------------------------------------------------------------------------------------------------------

//Schritt6 ---------------------------------------------------------------------------------------------------------------
if(((Sensoren[0] <= 0)||(Sensoren[1] <= 0)||(Sensoren[2] <= 0)||(Sensoren[3] <= 0)||(Sensoren[4] <= 0)||(Sensoren[5] <= 0)) &&(Schritt_Reihenfolge == 5)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt

  for(int x = 0; x < 6 ; x ++){
   
    if ((Sensoren[x] <= 3)&&(pruefer_sensor[x] == 0)&&(LED_Schritt[5] == 0)){ //zb 1

          LED_Schritt[5] = LEDs[x];
          Sensor_Schritt6= Sensoren_variable[x];  
          pruefer_sensor[x] = 1;
          Schritt_Reihenfolge = 6;
          Runde2 = 1;                                     
          x6 = x;
          Schritt6_vorgekommen  = 1;
      
    } 
  }
}
Sensor6_Zustand = analogRead(Sensor_Schritt6);

if((Sensor6_Zustand <= 0)&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_5 == 1)){
  digitalWrite(LED_Schritt[5],HIGH);
  if(Schritt6_vorgekommen  == 1){
    LED_ist_wieder_L_6 = 0;
    step6_immer_noch_H = 1;
  }
}



if(Sensor6_Zustand > 1){
  digitalWrite(LED_Schritt[5],LOW);
  pruefer_sensor[x6] = 0;
  LED_ist_wieder_L_6 = 1;
  step6_immer_noch_H = 0;
  //löschen
  LED_Schritt[5] = 0;
  Sensor_Schritt6= 0;
  Sensor6_Zustand = 0;
  Schritt6_vorgekommen  = 0;
}


//Ende Schritt 6 ------------------------------------------------------------------------------------------------------------

//Überspringt Schritt falls dieser Sensor in nächster Runde immer noch High ist
if((Schritt_Reihenfolge == 5)&&(step6_immer_noch_H == 1)){
  Schritt_Reihenfolge = 6;
  }
if((Schritt_Reihenfolge == 4)&&(step5_immer_noch_H == 1)){
  Schritt_Reihenfolge = 5;
  }
if((Schritt_Reihenfolge == 3)&&(step4_immer_noch_H == 1)){
  Schritt_Reihenfolge = 4;
  }
if((Schritt_Reihenfolge == 2)&&(step3_immer_noch_H == 1)){
  Schritt_Reihenfolge = 3;
  }
if((Schritt_Reihenfolge == 1)&&(step2_immer_noch_H == 1)){
  Schritt_Reihenfolge = 2;
  }
if((Schritt_Reihenfolge == 6)&&(step1_immer_noch_H == 1)){
  Schritt_Reihenfolge = 1;
  }          
  
}