Sie sind hier: Startseite / Das IPN / Ausbildung / box.txt

box.txt

Plain Text icon box.txt — Plain Text, 43 KB (44188 bytes)

Dateiinhalt

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F,20,4);                    //  LCD Adresse =0x3F ,  20Zeichen pro Zeile , 4 Zeilen
int incomingByte = 0;                                // Variable f�r einen Befehl von dem seriellen Monitor

#include <Servo.h>
Servo servo;


int sensor = A0;                                    //Variable f�r Sensorsignal-Input
int gls = A1;                      
int s0 = A2;    //a                                 //Variablen f�r Adressleitungen des Multiplexers
int s1 = 13;    //b
int s2 = 12;    //c
int led1 = 10;                                      //LED Variablen
int led2 = 9;
int led3 = 8;
int led4 = 7;
int led5 = 6;
int led6 = 5;
int led7 = 4;
int led8 = 3;
int led9 = 2; 
int bat = A3;                
int buttonPushCounter = 0;                          // Z�hler f�r Ver�nderung des Zustandes von Endschalter
int buttonState = 0;                                // current state of the button
int lastSchalter = 1023;                            // Vergleichswert f�r den Endschalterz�hler
int sensorNummer = 0;                               // Z�hler f�r Sensorreihenfolge
int potiWert = 0;                                   // Z�hler f�r den gesuchten Potentiometerwert
int jump = 0;
char a = 8;
char d = 3;
char e = 4;
char f = 5;
char ue = 6;
char ae = 7;
char h = 9;
char g = 10;

byte star[8] = {B00000, B00100, B00100, B11111, B01110, B01010, B10001, B00000};                         //Anzeigegraphik f�r Stern           

byte battery_low_a[8] = {B00000, B00000, B00000, B00000, B11111, B11111, B11111, B11111};                //Anzeigegraphiken f�r leere Batterie
  
byte battery_low_b [8] = {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};

byte battery_low_c[8] = {B11111, B11111, B11111, B00000, B11111, B11111, B11111, B11111};
byte uuml[8] = {B01010, B00000, B10001, B10001, B10001, B10011, B01101, B00000};                       //Anzeigegraphik f�r �
 
byte auml[8] = {B01010, B00000, B01110, B00001, B01111, B10001, B01111, B00000};                       //Anzeigegraphik f�r �

byte dunkel[8] = {B11111, B10001, B10001, B10001, B10001, B10001, B10001, B11111};                     //Anzeigegraphik f�r "dunkel"

byte dot[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B01010};                        //Anzeigegraphik f�r Umlautpunkte
void setup() {
Serial.begin(9600);                                                                                    //Seriellen Monitor mit der Baudrate 9600 initialisieren
      
lcd.init();                                                                                            //LCD-Display initialisieren
                                                                                                      
delay(10);      
lcd.createChar(a, star);                                                                               //"Stern"-Charakter erstellen
lcd.createChar(d, battery_low_a);                                                                      //"Batterie Leer"-Charakter (a, b und c)erstellen
lcd.createChar(e, battery_low_b);                                                                     
lcd.createChar(f, battery_low_c);                                                                      
lcd.createChar(ue, uuml);                                                                              //"�"-Charakter erstellen
lcd.createChar(ae, auml);                                                                              //"�"-Charakter erstellen
lcd.createChar(h, dunkel);                                                                              //Zeichen f�r "Dunkel" erstellen
lcd.createChar(g, dot);                                                                                //"Umlautpunkte"-Charakter erstellen
battery();                                                                                             //Funktion f�r Batteriecheck ausf�hren
lcd.clear();      
servo.attach(11);                                                                                      //Servo wird in Sperrposition gefahren 
servo.write(100);
delay(10);
      
pinMode(s0, OUTPUT);                                                                                   //Pinns f�r Multiplexersteuerung als Output deklarieren
pinMode(s1, OUTPUT);
pinMode(s2, OUTPUT);
for (int thisPin = 2; thisPin < 11; thisPin++)                                                         //LED-Pinns als Output deklarieren
     {pinMode(thisPin, OUTPUT);}
pinMode(bat, INPUT);                                                                                   //Pin zu �berpr�fung der Batterie als Input deklarieren 
pinMode(gls, OUTPUT);                                                                                  //Pin f�r Versorgung der Gabellichtschranke als Output deklarieren
      
text();}                                                                                               //Funktion f�r Willkommenstext wird durchlaufen
 
void loop() {

Anfang:
                                                      
delay(10);

if(sensorNummer == 0 ){                                                                                //Betr�gt die Zahl in Sensorfolge-Z�hler 0, f�hre folgendes aus:     
       
       analogWrite(s0, 0);                                                                            //Adressleitungen des Multiplexers ansteuern und dadurch den Reedschalter freischalten
       digitalWrite(s1, LOW);
       digitalWrite(s2, LOW);
       delay(10);
       reeds();                                                                                        // Hinweistext f�r Ansteuerung des Reedschalters wird angezeigt
       int reedValue = analogRead(sensor);                                                             // Signalwert des Reedschalters wird ausgelesen
       
      
       
                if(reedValue == 1023){                                                                 //Der erw�nschter Wert betr�gt 1023, ist dieser erreicht f�rhre folgendes aus: 
                   sensorNummer++;                                                                     //Erh�he die Zahl in Sensorfolge-Z�hler
                   digitalWrite(led9, HIGH);                                                           //Die zu Sensor geh�rige LED einmal blinken lassen
                  delay(500);
                  digitalWrite(led9, LOW);
                   delay(500);
                  digitalWrite(led9, HIGH);   
                   gut_gemacht();                                                                     //Den Lobtext anzeigen
                   delay(10);
                   lcd.clear();}                                                                      //Den Text auf dem Display l�schen                                            
}
   
if(sensorNummer == 1){                                                                               //Betr�gt die Zahl in Sensorfolge-Z�hler 1, f�hre folgendes aus:                          
  
       analogWrite(s0, 1023);                                                                        //Adressleitungen des Multiplexers ansteuern und dadurch den Lichtsensor freischalten
       digitalWrite(s1, LOW);
       digitalWrite(s2, LOW);
       digitalWrite(led9,LOW);                                                                       // Leuchtende LED ausschalten
       licht();                                                                                      // Hinweistext f�r Ansteuerung des Lichtsensors wird angezeigt
       int lsValue = analogRead(sensor);                                                             // Signalwert des Lichtsensors wird ausgelesen
       if (lsValue > 30){                                                                            //Betr�gt ist der Sensorwert gr��er als 30, f�hre folgendes aus
        int range = map(lsValue, 30, 250, 0, 8);                                                     //Teile die Werte zwischen 30 und 250 in neun Teile auf
        switch (range){                                                                              //Den Sensorwert des Lichtwiderstandes �berpr�fen und entsprechenden Befehl ausf�hren
                  
               case 0:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "0" f�hre folgendes aus:
               for (int thisPin = 2; thisPin < 11; thisPin++) {                                     //Schalte alle LEDs ein
                digitalWrite(thisPin, HIGH);
                }
      
               break;                                                                               //Verlasse die Schleife von "case 0"

               case 1:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "1" f�hre folgendes aus:
               for (int thisPin = 3; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED8 ein
                digitalWrite(thisPin, HIGH);
                }
               for (int thisPin = 2; thisPin < 3; thisPin++) {                                      //Schalte LED9 aus
                digitalWrite(thisPin, LOW);
                }
               break;                                                                               //Verlasse die Schleife von "case 1"

               case 2:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "2" f�hre folgendes aus:
                     
               for (int thisPin = 4; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED7 ein
                digitalWrite(thisPin, HIGH);
                }
      
               for (int thisPin = 2; thisPin < 4; thisPin++) {                                       //Schalte LED9-LED8 aus
                digitalWrite(thisPin, LOW);
                }
               break;                                                                               //Verlasse die Schleife von "case 2"
                
               case 3:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "3" f�hre folgendes aus:
                 
               for (int thisPin = 5; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED6 ein
                digitalWrite(thisPin, HIGH);
                }
      
               for (int thisPin = 2; thisPin < 5; thisPin++) {                                      //Schalte LED9-LED7 aus
                digitalWrite(thisPin, LOW);
                }
               break;                                                                               //Verlasse die Schleife von "case 3"

               case 4:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "4" f�hre folgendes aus:
                     
               for (int thisPin = 6; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED5 ein
                digitalWrite(thisPin, HIGH);
                }

               for (int thisPin = 2; thisPin < 6; thisPin++) {                                      //Schalte LED9-LED6 aus
                digitalWrite(thisPin, LOW);
                }
               break;                                                                               //Verlasse die Schleife von "case 4"

               case 5:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "5" f�hre folgendes aus:
                    
               for (int thisPin = 7; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED4 ein
                   digitalWrite(thisPin, HIGH);
                   }
               for (int thisPin = 2; thisPin < 7; thisPin++) {                                      //Schalte LED9-LED5 aus
                digitalWrite(thisPin, LOW);
                }
               break;                                                                               //Verlasse die Schleife von "case 5"

               case 6:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "6" f�hre folgendes aus:                                                                   
                
               for (int thisPin = 8; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED3 ein
                 digitalWrite(thisPin, HIGH);
                 }
               for (int thisPin = 2; thisPin < 8; thisPin++) {                                      //Schalte LED9-LED4 aus
                 digitalWrite(thisPin, LOW);
                 }
               break;                                                                               //Verlasse die Schleife von "case 6"

               case 7:                                                                              //Liegt der gemessener Wert in dem Werteumfang von Teil "7" f�hre folgendes aus:
                  
               for (int thisPin = 9; thisPin < 11; thisPin++) {                                     //Schalte LED1-LED2 ein
                  digitalWrite(thisPin, HIGH);
                  }
               for (int thisPin = 2; thisPin < 9; thisPin++) {                                      //Schalte LED9-LED3 aus
                  digitalWrite(thisPin, LOW);
                  }
               break;                                                                               //Verlasse die Schleife von "case 7"
                 
               case 8:                                                                               //Liegt der gemessener Wert in dem Werteumfang von Teil "8" f�hre folgendes aus:
                    
               for (int thisPin = 10; thisPin < 11; thisPin++) {                                     //Schalte LED1 ein
                  digitalWrite(thisPin, HIGH);
                  }
                
               for (int thisPin = 2; thisPin < 10; thisPin++) {                                      //Schalte LED9-LED2 aus
                 digitalWrite(thisPin, LOW);
                 }
               break;                                                                                 //Verlasse die Schleife von "case 8"
       default:                                                                                       //Liegt der gemessener Wert a�erhalb des Werteumfangs f�hre folgendes aus:
       for (int thisPin = 2; thisPin < 11; thisPin++) {                                               //Schalte LED1-LED9 aus
                digitalWrite(thisPin, LOW);  }
       }
       }
       if(lsValue <= 30){                                                                             //Der erw�nschter Wert betr�gt 30, ist dieser erreicht f�rhre folgendes aus:
       for (int thisPin = 2; thisPin < 11; thisPin++) {                                               //Schalte LED1-LED9 aus
                digitalWrite(thisPin, LOW);  }
                delay(1);
       
                                                             
                    sensorNummer++;                                               //erh�he die Zahl in Sensorfolge-Z�hler 
                    digitalWrite(led1, HIGH);                                     // LED1 und LED9 einmal blinken lassen
                    digitalWrite(led9, HIGH);
                    delay(500);
                    digitalWrite(led1, LOW);                                   
                    digitalWrite(led9, LOW);
                    delay(500);
                    digitalWrite(led1, HIGH);                                     
                    digitalWrite(led9, HIGH);
                    sehr_gut();                                                    //den Lobtext anzeigen
                    delay(10);
                    }

}
if(sensorNummer == 2 ){                                                           //Betr�gt die Zahl in Sensorfolge-Z�hler 2, f�hre folgendes aus:                          
     
       analogWrite(s0, 0);
       digitalWrite(s1, HIGH);                                                    //Adressleitungen des Multiplexers ansteuern und dadurch die Gabellichtschranke freischalten
       digitalWrite(s2, LOW);
       analogWrite(gls, 500);
       delay(10);
       lichtschranke();                                                           // Hinweistext f�r Ansteuerung der Gabellichtschranke wird angezeigt
       int glsValue = analogRead(sensor);                                         // Signalwert von Gabellichtschranke wird ausgelesen
      
       
              if(glsValue <= 10){                                                 //Der erw�nschter Wert betr�gt 10 oder weniger, ist dieser erreicht f�rhre folgendes aus: 
                 sensorNummer++;                                                  //erh�he die Zahl in Sensorfolge-Z�hler
                 digitalWrite(led8, HIGH);                                        //die zu Sensor geh�rige LED einschalten
                 
                 delay(500);
                 digitalWrite(led1, LOW);                                         // LED1,LED8 und LED9 einmal blinken lassen
                 digitalWrite(led8, LOW);               
                 digitalWrite(led9, LOW);
                 delay(500);
                 digitalWrite(led1,  HIGH);
                 digitalWrite(led8,  HIGH);               
                 digitalWrite(led9,  HIGH);
                 toll();                                                          //den Lobtext anzeigen
                 delay(10);
                 analogWrite(gls,0);}                                             
}  
  
if(sensorNummer == 3 ){                                                           //Betr�gt die Zahl in Sensorfolge-Z�hler 3, f�hre folgendes aus:            
    
       analogWrite(s0, 1023);                                                     //Adressleitungen des Multiplexers ansteuern und dadurch den Hallsensor freischalten
       digitalWrite(s1, HIGH);
       digitalWrite(s2, LOW);
       halls();                                                                   // Hinweistext f�r Ansteuerung des Hallsensors wird angezeigt
       int hallValue = analogRead(sensor);                                        // Signalwert des Hallsensors wird ausgelesen
       delay(10);
       digitalWrite(led5, HIGH);                                                  //Schalte LED5 ein
              for (int thisPin = 2; thisPin < 6; thisPin++){                      //Schalte LED1-LED4 und LED6-LED9 aus
                        digitalWrite(thisPin, LOW);}
              for (int thisPin = 7; thisPin < 11; thisPin++){
                        digitalWrite(thisPin, LOW);}
                  
if (hallValue < 300 && hallValue > 20){                                           //Ist der Sensorwert kleiner als 300 und gr��er als 20, f�hre folgendes aus
    for (int thisPin = 7; thisPin < 11; thisPin++) {                              //Schalte LED1-LED4 aus
                digitalWrite(thisPin, LOW);
                }
    int range = map(hallValue, 20, 199, 0, 3);                                    //Teile die Werte zwischen 20 und 199 in vier Teile auf
        switch (range){                                                           //Den Sensorwert des Hallsensors �berpr�fen und entsprechenden Befehl ausf�hren
          delay(10);
          case 0:                                                                 //Liegt der gemessener Wert in dem Werteumfang von Teil "0" f�hre folgendes aus:
          for (int thisPin = 2; thisPin < 6; thisPin++) {                         //Schalte LED6-LED9 ein
                digitalWrite(thisPin, HIGH);
                }
          break;                                                                  //Verlasse die Schleife
          
          case 1:                                                                 //Liegt der gemessener Wert in dem Werteumfang von Teil "1" f�hre folgendes aus:
          for (int thisPin = 3; thisPin < 6; thisPin++) {                         //Schalte LED6-LED8 ein
                digitalWrite(thisPin, HIGH);
                }
          for (int thisPin = 2; thisPin < 3; thisPin++) {                         //Schalte LED9 aus
                digitalWrite(thisPin, LOW);
                }
          break;                                                                  //Verlasse die Schleife
          
          case 2:                                                                 //Liegt der gemessener Wert in dem Werteumfang von Teil "2" f�hre folgendes aus:
           for (int thisPin = 4; thisPin < 6; thisPin++) {                        //Schalte LED6 und LED7 ein
                digitalWrite(thisPin, HIGH);
                }
          for (int thisPin = 2; thisPin < 4; thisPin++) {                         //Schalte LED9 und LED8 aus
                digitalWrite(thisPin, LOW);           
                }
          break;                                                                   //Verlasse die Schleife
       
          case 3:                                                                  //Liegt der gemessener Wert in dem Werteumfang von Teil "3" f�hre folgendes aus:
            for (int thisPin = 5; thisPin < 6; thisPin++) {                        //Schalte LED6 ein
                digitalWrite(thisPin, HIGH);
                }
          for (int thisPin = 2; thisPin < 5; thisPin++) {                          //Schalte LED7 - LED9 aus
                digitalWrite(thisPin, LOW);
                }
          break;                                                                   //Verlasse die Schleife
          default: for (int thisPin = 2; thisPin < 6; thisPin++){                  //Liegt der gemessener Wert a�erhalb des Werteumfangs f�hre folgendes aus:
                        digitalWrite(thisPin, LOW);}                               //Schalte LED6 - LED9 aus
          }} 


if (hallValue > 600){                                                              //Ist der Sensorwert gr��er als 600, f�hre folgendes aus:
  for (int thisPin = 2; thisPin < 6; thisPin++){
                        digitalWrite(thisPin, LOW);}                               //Schalte LED9-LED6 aus
   int range = map(hallValue, 700, 1000, 0, 3);                                    //Teile die Werte zwischen 700 und 1000 in vier Teile auf
        switch (range){                                                            //Den Sensorwert des Hallsensors �berpr�fen und entsprechenden Befehl ausf�hren
          delay(10);
          case 0:                                                                  //Liegt der gemessener Wert in dem Werteumfang von Teil "0" f�hre folgendes aus:
          for (int thisPin = 7; thisPin < 8; thisPin++) {                          //Schalte LED4 ein
                digitalWrite(thisPin, HIGH);
                }
          for (int thisPin = 8; thisPin < 11; thisPin++) {                          //Schalte LED3 - LED1 aus                   
                digitalWrite(thisPin, LOW);
                }
          break;                                                                    //Verlasse die Schleife
          
          case 1:                                                                    //Liegt der gemessener Wert in dem Werteumfang von Teil "1" f�hre folgendes aus:
          for (int thisPin = 7; thisPin < 9; thisPin++) {                            //Schalte LED4 und LED3 ein
                            digitalWrite(thisPin, HIGH);
                }
          for (int thisPin = 9; thisPin < 11; thisPin++) {                           //Schalte LED2 und LED1 aus 
                digitalWrite(thisPin, LOW);
                }
          break;                                                                     //Verlasse die Schleife
          
          case 2:                                                                    //Liegt der gemessener Wert in dem Werteumfang von Teil "2" f�hre folgendes aus:
            for (int thisPin = 7; thisPin < 10; thisPin++) {                         //Schalte LED4 - LED2 ein
                digitalWrite(thisPin, HIGH);
                }
          for (int thisPin = 10; thisPin < 11; thisPin++) {                          //Schalte LED1 aus 
                digitalWrite(thisPin, LOW);
                }
          break;                                                                     //Verlasse die Schleife
       
          case 3:                                                                    //Liegt der gemessener Wert in dem Werteumfang von Teil "2" f�hre folgendes aus:
           for (int thisPin = 7; thisPin < 11; thisPin++) {                          //Schalte LED4 - LED1 ein
                digitalWrite(thisPin, HIGH);
                }
          break;                                                                     //Verlasse die Schleife
          default: for (int thisPin = 7; thisPin < 11; thisPin++) {                  //Liegt der gemessener Wert a�erhalb des Werteumfangs f�hre folgendes aus:
                        digitalWrite(thisPin, LOW);}                                 //Schalte LED4 - LED1 aus    
          }}

                
     
              if(hallValue < 20){                                                //Der erw�nschter Wert betr�gt 20 oder weniger, ist dieser erreicht f�rhre folgendes aus: 
                 sensorNummer++;                                                 //Erh�he die Zahl in Sensorfolge-Z�hler
                digitalWrite(led5, LOW);                                         //Schalte LED5 aus und lasse LED9, LED8, LED2 und LED1 blinken
                 for(int thisPin = 2; thisPin < 4; thisPin++)                                    
                      {digitalWrite(thisPin, HIGH);}
                 for(int thisPin = 9; thisPin < 11; thisPin++)                                    
                      {digitalWrite(thisPin, HIGH);}
                 delay(500);
                 for(int thisPin = 2; thisPin < 4; thisPin++)                                    
                      {digitalWrite(thisPin, LOW);}
                 for(int thisPin = 9; thisPin < 11; thisPin++)                                    
                      {digitalWrite(thisPin, LOW);}
                 delay(500);
                 for(int thisPin = 2; thisPin < 4; thisPin++)                                    
                      {digitalWrite(thisPin, HIGH);}
                 for(int thisPin = 9; thisPin < 11; thisPin++)                                    
                      {digitalWrite(thisPin, HIGH);}
                 delay(500);
                 fast();                                                        //Den Lobtext anzeigen                                      
                 delay(10);}
}

if(sensorNummer == 4){                                                          //Betr�gt die Zahl in Sensorfolge-Z�hler 4, f�hre folgendes aus:            
   
   analogWrite(s0, 0);                                                          //Adressleitungen des Multiplexers ansteuern und dadurch den Potentiometer freischalten
   digitalWrite(s1, LOW); 
   digitalWrite(s2, HIGH);
 
      if (potiWert == 0){                                                      //Betr�gt die Zahl in Potiwert-Reihenfolge Z�hler 0, f�hre folgendes aus:                                                  
           int potiState = analogRead(sensor);                                 //Signalwert des Potentiometers auslesen                              
           tresor();                                                           // Hinweistext anzeigen                                                    
           delay(10);
                        
           if(potiState >= 800 && potiState <= 1023){                          //Der erste gew�nschte Wert soll zwischen 800 und 1023 liegen. Ist diese Bedignung erf�llt f�hre folgendes aus:
              digitalWrite(led7, HIGH);                                        //Die zu Aufgabe geh�rige LED einschalten                                    
              potiWert++;                                                      //Erh�he die Zahl in Zahl in Potiwert-Reihenfolge Z�hler
              delay(10);}
           }
          
      if (potiWert == 1 ){                                                  //Betr�gt die Zahl in Potiwert-Reihenfolge Z�hler 1, f�hre folgendes aus:                                             
            int potiState = analogRead(sensor);                             //Signalwert des Potentiometers auslesen
            tresor();                                                       //Hinweistext anzeigen 
            delay(10);
                             
            if(potiState >= 1 && potiState <= 10){                          //Der zweite gew�nschte Wert soll zwischen 1 und 10 liegen. Ist diese Bedignung erf�llt f�hre folgendes aus:
               digitalWrite(led3, HIGH);                                    //die zu Aufgabe geh�rige LED einschalten 
               delay(10);
               potiWert++;                                                  //Erh�he die Zahl in Zahl in Potiwert-Reihenfolge Z�hler
               delay(10);}
        }
         
      if (potiWert == 2){                                                   //Betr�gt die Zahl in Potiwert-Reihenfolge Z�hler 2, f�hre folgendes aus:                          
           int potiState = analogRead(sensor);                              //Signalwert des Potentiometers auslesen
           tresor();                                                        // Hinweistext anzeigen 
           delay(10);    
                          
           if(potiState >= 700 && potiState <= 750){                         //Der dritter gew�nschte Wert soll zwischen 700 und 750 liegen. Ist diese Bedignung erf�llt f�hre folgendes aus:
              digitalWrite(led6, HIGH);                                      //die zu Aufgabe geh�rige LED einschalten 
              delay(10);
              potiWert++;                                                    //erh�he die Zahl in Potiwert-Reihenfolge Z�hler
              delay(10);}
              }
        
      if (potiWert == 3){                                                  //Betr�gt die Zahl in Potiwert-Reihenfolge Z�hler 3, f�hre folgendes aus: 
          int potiState = analogRead(sensor);                              //Signalwert des Potentiometers auslesen
          delay(10);
          tresor();                                                        // Hinweistext anzeigen              
          
          if(potiState >= 100 && potiState <= 150){                        //Der vierter gew�nschte Wert soll zwischen 100 und 150 liegen. Ist diese Bedignung erf�llt f�hre folgendes aus:
             digitalWrite(led4, HIGH);                                     //Die zu Aufgabe geh�rige LED einschalten 
             delay(10);
             potiWert++;                                                   //Erh�he die Zahl in Zahl in Potiwert-Reihenfolge Z�hler                           
             delay(10); }
         }
           
      if (potiWert== 4){                                                   //Betr�gt die Zahl in Potiwert-Reihenfolge Z�hler 3, f�hre folgendes aus: 
          int potiState = analogRead(sensor);                              //Signalwert des Potentiometers auslesen
          tresor();                                                        // Hinweistext anzeigen              
          delay(10); 
                               
          if(potiState >= 300 && potiState <= 360 ){                      //Der letzter gew�nschte Wert soll zwischen 300 und 360 liegen. Ist diese Bedignung erf�llt f�hre folgendes aus:
             digitalWrite(led5, HIGH);                                    //Die zu Aufgabe geh�rige LED einschalten 
             delay(10); 
             potiWert++;                                                  //Erh�he die Zahl in Zahl in Potiwert-Reihenfolge Z�hler
             lcd.setCursor(16,2);
             lcd.print(a);
             sensorNummer++;                                              //Erh�he die Zahl in Sensorfolge-Z�hler
             delay(10);}   
         }
}
 
if(sensorNummer == 5){                                                      //Betr�gt die Zahl in Sensorfolge-Z�hler 5, f�hre folgendes aus:  
   analogWrite(s0, 1023);                                                   //Adressleitungen des Multiplexers ansteuern und dadurch den Endschalter freischalten
   digitalWrite(s1, LOW);
   digitalWrite(s2, HIGH);
   lcd.clear();
   glueckwunsch();
   delay(4000);
   lcd.clear();
   belohnung();
   delay(4000);
   lcd.clear();
   delay(500);
   servo.write(10);                                                          //Servo in die "�ffnen" Position fahren
   delay(100);
   jump++;
   sensorNummer++;
   delay(10);}
 
if(jump == 1 && sensorNummer == 6){
       int Schalter = analogRead(sensor);                                   //Zustand des Endschalters auslesen
      delay(10);
      for(int thisPin = 2; thisPin < 11; thisPin++)                                    
    {digitalWrite(thisPin, LOW);}
      lcd.noBacklight();
      delay(10);
if (Schalter != lastSchalter) {                                             //Weicht der Endschalterwert von vorgegebenen Wert ab f�rhre folgendes aus:
   
    
    if (Schalter == 0) {                                                   //Ist der Endschalterwert 0(der Aufbewahrungsfach wird ge�ffnet):
   
                                                                           //Vergleichswert f�r den Endschalterz�hler wird automatisch auf den Wert 0 gesetzt
   
   
   
                 
     
        delay(10);    
        buttonPushCounter++;                                            // Erh�he der wert in Endschalterz�hler
       
        delay(10); }
       
       
    if(Schalter == 1023 ) {                                             //Ist der Endschalterwert 1023(der Aufbewahrungsfach wird wieder geschlossen):
       
       delay(10);    
       buttonPushCounter++;                                             // Erh�he der wert in Endschalterz�hler
      
       }
        
    }
    delay(50);
    lastSchalter = Schalter; }                                         //Vergleichswert f�r den Endschalterz�hler wieder auf 1023 setzten
   
  
 if( buttonPushCounter == 2){                              //Betr�gt der wert in Endschalterz�hler 2, f�hre folgendes aus:
     buttonPushCounter = 0;                                //Z�hler f�r Endschalter zur�cksetzten
     potiWert = 0;                                         //Der Z�hler f�r Potiwert-Reihenfolge Z�hler zur�cksetzten
     sensorNummer = 0;                                     //Der Z�hler f�r Sensorreihenfolge wird zur�cksetzten
     jump = 0;
     delay(90);
     servo.attach(11);                                     //Servo in die Sperrposition fahren
     servo.write(100);
     delay(90);
     
     delay(1000); 
     battery();                                            //Funktion f�r die �berpr�fung der Batterie wird durchgelaufen
     text();                                               //Wilkommenstext wird Angezeigt
     delay(1000);
     goto Anfang;}                                         //Loopfunktion startet von vorne
     }

void text(){  
                                                          //Willkommenstext und Anweisungen
     lcd.setCursor(0,0);
     lcd.print("Herzlich Willkommen!");
     delay(2000);
     lcd.clear();
     delay(500);
     lcd.setCursor(0,0);
     lcd.print("    Anweisungen:    ");
     lcd.setCursor(0,1);
     lcd.print("Steuere die Sensoren");
     lcd.setCursor(0,2);
     lcd.print("  in der richtigen  ");
     lcd.setCursor(0,3);
     lcd.print("   Reihenfolge an!  ");
     delay(4500);
     lcd.setCursor(0,1);
     lcd.print("                    ");
     lcd.setCursor(0,2);
     lcd.print("Folge den Hinweisen!");
      lcd.setCursor(0,3);
     lcd.print("                    ");
     delay(4500);
     lcd.clear();
     delay(10);
     lcd.setCursor(0,0);
     lcd.print("  Das I.P.N w");
     lcd.setCursor(13,0);
     lcd.print(ue);
     lcd.setCursor(14,0);
     lcd.print("nscht ");
     lcd.setCursor(0,1);
     lcd.print("     viel Freude    ");
     lcd.setCursor(0,2);
     lcd.print("    beim R");
     lcd.setCursor(10,2);
     lcd.print(ae);
     lcd.setCursor(11,2);
     lcd.print("tseln!   ");
     delay(4500);
     lcd.clear();}

void reeds(){                                                   //Hinweistext f�r Ansteuerung des Reedschalters
       int reedValue = analogRead(sensor);
       lcd.setCursor(0,0);
       lcd.print("Erster Sensor sagt: ");
       lcd.setCursor(0,1);
       lcd.print(" Ich muss n");
       lcd.setCursor(11,1);
       lcd.print(ae);
       lcd.setCursor(12,1);
       lcd.print("her ans");
       lcd.setCursor(0,2);
       lcd.print("    Magnetfeld!    ");
       lcd.setCursor(0,3);
      
       delay(10);}
     
void licht(){                                                 //Hinweistext f�r Ansteuerung des Lichtsensor
      int lsValue = analogRead(sensor);
      lcd.setCursor(0,0);
      lcd.print("Zweiter Sensor sagt: ");
      lcd.setCursor(0,1);
      lcd.print("   Mir ist es hier  ");
      lcd.setCursor(0,2);
      lcd.print("    viel zu hell!   ");
      lcd.setCursor(0,3);
      lcd.print(h);
      lcd.setCursor(19,3);
      lcd.print(e);
     
      delay(10);}
     
void lichtschranke(){                                         //Hinweistext f�r Ansteuerung der Gabellichtschranke
       int glsValue = analogRead(sensor);
       lcd.setCursor(0,0);
       lcd.print("Dritter Sensor sagt: ");
       lcd.setCursor(0,1);
       lcd.print("     Unterbreche    ");
       lcd.setCursor(0,2);
       lcd.print("     das Signal!    ");
       lcd.setCursor(0,3);
      
       delay(10);}

void halls(){                                                //Hinweistext f�r Ansteuerung des Hallsensors
       int hallValue = analogRead(sensor);
       lcd.setCursor(0,0);
       lcd.print("Vierter Sensor sagt: ");
       lcd.setCursor(0,1);
       lcd.print("  Auf zum Nordpol!  ");
       lcd.setCursor(0,3);
       lcd.print("N");
       lcd.setCursor(19,3);
       lcd.print("S");
       delay(10);}

void tresor(){                                               //Hinweistext f�r das Tresorspiel
           int potiState = analogRead(sensor);
          lcd.setCursor(2,0);
          lcd.print(g);
          lcd.setCursor(2,1);
          lcd.print("Offne den Tresor!  ");
              if(potiWert == 1){
              lcd.setCursor(4,2);
              lcd.print(" "); 
              lcd.setCursor(4,2);
              lcd.print(a); 
              }
              else{
               lcd.setCursor(4,2);
               lcd.print(e); 
              }
          
              if(potiWert == 2){ 
              lcd.setCursor(16,2);
              lcd.print(" "); 
              lcd.setCursor(16,2);
              lcd.print(a); 
              }
               else{
               lcd.setCursor(16,2);
               lcd.print(e); 
              }
        
              if(potiWert == 3){
              lcd.setCursor(7,2);
              lcd.print(" "); 
              lcd.setCursor(7,2);
              lcd.print(a); 
              }
               else{
               lcd.setCursor(7,2);
               lcd.print(e); 
              }
        
               if(potiWert == 4){ 
               lcd.setCursor(13,2);
               lcd.print(" "); 
               lcd.setCursor(13,2);
               lcd.print(a); 
               }
                else{
               lcd.setCursor(13,2);
               lcd.print(e); 
              }
      
              if(potiWert == 5){ 
              lcd.setCursor(10,2);
              lcd.print(" "); 
              lcd.setCursor(10,2);
              lcd.print(a); 
              }
               else{
               lcd.setCursor(10,2);
               lcd.print(e); 
              }
          delay(10);}

void gut_gemacht(){                                             //Lobtexte f�r gel�ste R�tsel
            lcd.clear();
            lcd.setCursor(0,1);
            lcd.print("    Gut gemacht!    ");
            delay(2500);
            lcd.clear();}

void sehr_gut(){
            lcd.clear();
            lcd.setCursor(0,1);
            lcd.print("      Sehr gut!     ");
            delay(2500);
            lcd.clear();}

void toll(){
            lcd.clear();
            lcd.setCursor(0,1);
            lcd.print("       Toll!      ");
            delay(2500);
            lcd.clear();}  

void fast(){
            lcd.clear();
            lcd.setCursor(0,1);
            lcd.print("    Fast am Ziel!   ");
            lcd.setCursor(0,3);
            lcd.print("    Und jetzt...    ");
            delay(2500);
            lcd.clear();}  

void glueckwunsch() {
            lcd.setCursor(0,0);
            lcd.print("    Gl");
            lcd.setCursor(6,0);
            lcd.print(ue);
            lcd.setCursor(7,0);
            lcd.print("ckwunsch!");
            lcd.setCursor(0,1);
            lcd.print("    Du hast alle    ");
            lcd.setCursor(0,2);
            lcd.print(" Aufgaben bestanden!");
            }

void belohnung(){
             
             lcd.setCursor(0,1);
             lcd.print("   Hole dir deine   ");
             lcd.setCursor(0,2);
             lcd.print("   Belohnung ab !   ");
                }
void battery(){ 
             lcd.backlight();                                              //Der Batteriezustand wird abgefragt
     lcd.setCursor(19,3);
     int batState = analogRead(bat);
     
     if(batState < 550){                                                  //Ist die Batterie zu schwach, wird "Batterie leer" angezeigt und das Program angehalten
        
        do{lcd.setCursor(0,1);
           lcd.print("    Batterie    ");
           lcd.setCursor(0,2);
           lcd.print("     leer!      ");                           
           lcd.setCursor(16,0);
           lcd.print(d);
           lcd.setCursor(17,0);
           lcd.print(f);
           lcd.setCursor(18,0);
           lcd.print(f);
           lcd.setCursor(19,0);
           lcd.print(d);
           lcd.setCursor(16,1);
           lcd.print(e);
           lcd.setCursor(19,1);
           lcd.print(e);
           lcd.setCursor(16,2);
           lcd.print(e);
           lcd.setCursor(19,2);
           lcd.print(e);
           lcd.setCursor(16,3);
           lcd.print(e);
           lcd.setCursor(17,3);
           lcd.print(d);
           lcd.setCursor(18,3);
           lcd.print(d);
           lcd.setCursor(19,3);
           lcd.print(e);
           delay(120.000);
           }
           while(batState < 550);}
           
           
           
           }