Türschloss

Hi

Ich wollte ein einfaches kleines digitales Schloss programmieren. Ist die eingegebene vierstellige Kombination Richtig leuchtet eine grüne LED und es gibt einen Piepton und wenn die Eingabe Falsch war Leuchtet die Rote LED und es ertönt einen anderer Ton. Das Codeschloss besteht dabei aus vier Buttons also den Zahlen 1-4. Zusätzlich soll bei 3x falscher Codeeingabe der ein Alarmton inklusive Blinklicht ausgelöst werden.

Leider Funktioniert mein Code nicht korrekt und ich finde den Fehler nicht. Der Compiler gibt mir keinen Fehler aus, ich vermute daher einen Fehler in der Logik des Programmes. Danke bereits im voraus für Hilfe.

  // Knöpfe weleche gedrückt werden
    int eingabe[4];

 
    // Gesetztes Passwort
    int passwort[4];

 
    // Löscht die aktuelle Eingabe
    int clear;

 
    // Eingabe überprüfungs Variable
    boolean invalid = false;

 
    // Zählungsvariable zur Einlesung
    int count = 1;

 
    // Variable um einen Passwort Check durchzuführen
    boolean check = false;

    //Variable für 3x Falsches Passwort 
    int alarm = 0;
 
void
setup() 
{
   
    // Inizialisierung der Schalter 
    pinMode(13, INPUT);
   
    pinMode(12, INPUT);
   
    pinMode(11, INPUT);
   
    pinMode(10, INPUT);
   
 
    // LEDs
    pinMode(7, OUTPUT); // Rote LED
    pinMode(8, OUTPUT); // Grüne LED
   
    // Lautsprecher
    pinMode(4, OUTPUT);
   
 
    // Clear Button
    pinMode(2, INPUT);

               
 
    // Inizialisierung
    passwort[0] = 1;
   
    passwort[1] = 2;
   
    passwort[2] = 3;
   
    passwort[3] = 4;
   
 
    eingabe[0] = 1;
   
    eingabe[1] = 2;
   
    eingabe[2] = 3;
       
    eingabe[3] = 4;

} 
    //Überprüft die Tasteneingabe es müssen 4 Knöpfe gedrückt worden sein 
void
    uberpruefe(int tasteneingabe)
{
    
if (count == 1) {
   
    passwort[0] = tasteneingabe;
   
    count++;
    
}
    
for (int i = 1; i < sizeof(passwort) / sizeof(passwort[0]); i++) {
   
    passwort[i] = tasteneingabe;
   
    count++;
    
}
    
if (count == 4) {
   
    count = 1;
   
    check = true;
    
}

}

 
void
loop() 
{
   
    //Benutzer eingabe B1
    if (digitalRead(13) == HIGH) {
   
        uberpruefe(1);
    
}
   
    //Benutzer eingabe B1 
    if (digitalRead(12) == HIGH) {
   
        uberpruefe(2);
    
}
   
    //Benutzer eingabe B1
    if (digitalRead(11) == HIGH) {
   
        uberpruefe(3);
    
}
   
    //Benutzer eingabe B1
    if (digitalRead(10) == HIGH) {
   
        uberpruefe(4);
    
}
   
 
   
    // Passwort Korrekt?
    if (check) {
   
    for (int i = 0; i < sizeof(passwort) / sizeof(passwort[0] - 1);
          i++) 
          
{
       
        if (passwort[i] == eingabe[i]) {
       
        } 
        else {
       
        invalid = true;
        alarm++;
       
        }
    
}
    //3x Falsches Passwort Alarm
     if(alarm = 3);{
     tone(4, 50, 1000);
     digitalWrite(7, LOW);
     delay(1000);
     tone(4, 50, 1000);
     digitalWrite(7, HIGH);
     delay(1000);
     tone(4, 50, 1000);
     digitalWrite(7, LOW);
     delay(1000);
     digitalWrite(7, HIGH);
     alarm = 0; 
     }

   
    //Korrektes Passwort
    if (invalid == false) {
       
        digitalWrite(8, LOW);
       
        digitalWrite(7, HIGH);
       
        tone(4, 100, 1000);
       
        delay(5000);
       
        digitalWrite(8, HIGH);
       
        digitalWrite(7, LOW);
       
        tone(4, 150, 1000);
    
}
   
    //1x falsches Passwort
    else {
    tone(4, 50, 1000);
    delay(1000);
    
}
    
}

 
 
 
}

Es wäre besser, wenn du den Sketch kommentierst, so weiß man nicht was da abläuft.

Was geht nicht korrekt?
Du solltest mal eine genaue Fehlerbeschreibung abgeben, was geht und was nicht geht.

Wo sollen wir den so anfangen zu suchen und wonach?

Hi

Danke für die schnelle Antwort.
Aktuell Leuchtet nur eine Rote LED wenn ich den Code aufs Board hochlade und egal welche Knöpfe ich drücke, es passiert nichts weiter. Habe den Code nun Kommentiert.

// Knöpfe welche gedrückt werden
    int eingabe[4];

 
    // Gesetztes Passwort
    int passwort[4];

 
    // Eingabe überprüfungs Variable
    boolean invalid = false;

 
    // Zählungsvariable zur Einlesung
    int count = 1;

 
    // Variable um einen Passwort Check durchzuführen
    boolean check = false;

    //Variable für 3x Falsches Passwort 
    int alarm = 0;
 
void setup() 
{
   
    // Inizialisierung der Schalter 
    pinMode(13, INPUT);//Schalter 1
   
    pinMode(12, INPUT);/Schalter 2
   
    pinMode(11, INPUT);/Schalter 3
   
    pinMode(10, INPUT);/Schalter 4
   
 
    // LEDs
    pinMode(7, OUTPUT); // Rote LED
    pinMode(8, OUTPUT); // Grüne LED
   
    // Lautsprecher
    pinMode(4, OUTPUT);
   
 
    // Clear Button
    pinMode(2, INPUT);

               
 
    // Setzen des Richtigen Passwortes
    passwort[0] = 1;
   
    passwort[1] = 2;
   
    passwort[2] = 3;
   
    passwort[3] = 4;
   
 //Setzen der Eingabe
    eingabe[0] = 1;
   
    eingabe[1] = 2;
   
    eingabe[2] = 3;
       
    eingabe[3] = 4;

} 



//Überprüft die Tasteneingabe es müssen 4 Knöpfe gedrückt worden sein 

void uberpruefe(int tasteneingabe)
{
    
if (count == 1) {
   
    passwort[0] = tasteneingabe;
   
    count++;
    
}
    
for (int i = 1; i < sizeof(passwort) / sizeof(passwort[0]); i++) {
   
    passwort[i] = tasteneingabe;
   
    count++;
    
}
    
if (count == 4) {
   
    count = 1;
   
    check = true;
    
}

}

//Registrierung der Benutzereingabe
 
void oop() 
{
   
    //Benutzer eingabe B1
    if (digitalRead(13) == HIGH) {
   
        uberpruefe(1);
    
}
   
    //Benutzer eingabe B1 
    if (digitalRead(12) == HIGH) {
   
        uberpruefe(2);
    
}
   
    //Benutzer eingabe B1
    if (digitalRead(11) == HIGH) {
   
        uberpruefe(3);
    
}
   
    //Benutzer eingabe B1
    if (digitalRead(10) == HIGH) {
   
        uberpruefe(4);
    
}
   
 
   
//Überprüft ob das Passwort korrekt ist?
    if (check) {
   
    for (int i = 0; i < sizeof(passwort) / sizeof(passwort[0] - 1);
          i++) 
          
{
       
        if (passwort[i] == eingabe[i]) {
       
        } 
        else {
       
        invalid = true;
        alarm++;
       
        }
    
}
    //Alarm der bei 3x falschem Passwort ausgelöst werden soll

     if(alarm = 3);{
     tone(4, 50, 1000);
     digitalWrite(7, LOW);
     delay(1000);
     tone(4, 50, 1000);
     digitalWrite(7, HIGH);
     delay(1000);
     tone(4, 50, 1000);
     digitalWrite(7, LOW);
     delay(1000);
     digitalWrite(7, HIGH);
     alarm = 0; 
     }

   
    //Entspert bei korrekter Passworteingabe & die grüne LED Leuchtet
    if (invalid == false) {
       
        digitalWrite(8, LOW);
       
        digitalWrite(7, HIGH);
       
        tone(4, 100, 1000);
       
        delay(5000);
       
        digitalWrite(8, HIGH);
       
        digitalWrite(7, LOW);
       
        tone(4, 150, 1000);
    
}
   
    //Ton nach Eingabe eines Falschen Passwortes
    else {
    tone(4, 50, 1000);
    delay(1000);
    
}
    
}

 
 
 
}

Wie hast du die Tasten entprellt?

Habe ich nicht, benutze die Standardtasten die es beim Ardiuno Uno Kit dazu gab.

selected:
Habe ich nicht, benutze die Standardtasten die es beim Ardiuno Uno Kit dazu gab.

Dann ist das schon mal ein grober Fehler, der auch eine Ursache sein kann. Beim Prellen entstehen sehr viele Impulse, die deinen Zähler schon ans Ende bringen können.

Entprelle per Hardware oder per Library:

Entprellen

Debounce

Und du solltest auch Pullup-Widerstände einsetzen.

Das geht über: pinMode(10, INPUT_PULLUP);

Deine Überprüfungslogik habe ich jetzt auf die schnelle nicht durchblickt.

In unkritischen Fällen kann man auch durch ein kleines Delay(50) entprellen. Das Problem bei deinem Code ist, dass er nicht wartet, bis die Taste wieder losgelassen wird. Der Computer fragt tausende mal pro Sekunde die Tasten ab. Bei jedem Durchlauf wird das als neuer Tastendruck registriert. So schnell kannst du die Taste gar nicht loslassen. Ich würde mir die Eingaben über den seriellen Monitor ausgeben lassen um sicher zustellen, dass alles richtig registriert wird.

    //Benutzer eingabe B1
    if (digitalRead(13) == HIGH) { do
                          {
                           delay(50); //Entprellen für Arme
                          } while (digitalRead(13)==HIGH);/Leerschleife solange die Taste gedrückt bleibt

   
        uberpruefe(1);

Deine Latte an Abfragen könnten man mit einer for-Schleife eleganter machen

Habe nun nochmals neu begonnen und den Code besser strukturiert, kommentiert und Entprellen eingebaut. Folgendes Problem habe ich aber noch:

Die rote LED leuchtet nicht von Anfang an, obwohl ich sie in de loop gepackt habe.
Gebe ich nun den Richtigen Code 1234 ein ertönt der 1x Fehler ton.
Gebe ich einen beliebigen Falschen Code ein passiert gar nichts.

Was hingegen funktioniert ist der Alarm bei 3x falscher Passworteingabe.

Könnt ihr mir weiterhelfen?

//Knöpfe weleche gedrückt werden
int button1;
int button2;
int button3;
int button4;
int fehler = 0;
boolean result;
int gedruckt = 0;

int eingabe[4];
int code[4];

void setup()
{
Serial.begin(9600);
//Inizialisierung der Schalter   
pinMode(13, INPUT);
pinMode(12, INPUT);
pinMode(11, INPUT);
pinMode(10, INPUT);

//LEDs
pinMode(7, OUTPUT);//Rote LED
pinMode(8, OUTPUT);//Grüne LED

//Lautsprecher
pinMode(4, OUTPUT);

//Setze das richtige Passwort
code[0]=1;
code[1]=2;
code[2]=3;
code[3]=4;

//Setze die Eingabe auf 0
eingabe[0]=0;
eingabe[1]=0;
eingabe[2]=0;
eingabe[3]=0;

}

void loop()
{   digitalWrite(7, HIGH);//Rote LED ist ein 
    digitalWrite(8, LOW);//Grüne LED ist aus
    
    //Benutzer eingabe B1
    if (digitalRead(13) == HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(13)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[0]=1; 
    gedruckt++;    
    }

    //Benutzer eingabe B2
    if (digitalRead(12) == HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(12)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[1]=2;
    gedruckt++;
    }

    //Benutzer eingabe B3
    if (digitalRead(11) == HIGH) { do
                          {
                           delay(50); //Entprellen 
                          } while (digitalRead(11)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[2]=3;
    gedruckt++;
    }

    //Benutzer eingabe B4
    if (digitalRead(10) == HIGH) { do
                          {
                           delay(50); //Entprellen 
                          } while (digitalRead(10)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[3]=4;
    gedruckt++;
    }
    
if(gedruckt == 4)//Überprüft ob 4 Tasten gedrückt worden sind 
{

   
            //Passwort Korrekt?
            //Setze die Variablen für den vergleich
            for (int x=0; x<4; x++){ 
            int test1 = code[x];//Vergleicht die beiden Variablen Wert für Wert
            int test2 = eingabe[x];
  
  
            if(code != eingabe){ //Sind sie nicht gleich das Resultat ist 0
            result = false; 
            }
  
            }
            if(result == true)// Die Arrays sind gleich
            { 
            digitalWrite(8, LOW);      
            digitalWrite(7, HIGH);      
            tone(4, 100, 1000);      
            delay(5000);     
            digitalWrite(8, HIGH);
            digitalWrite(7, LOW);
            tone(4, 150, 1000);
            eingabe[4]= 0,0,0,0;//Setzt die Eingabe wieder auf 0
            }
            
            if(result == false){ // Die Arrays sind ungleich
                digitalWrite(7, HIGH);//Rote LED ist ein 
                tone(4, 50, 1000);
                delay(50);
                fehler++;//Erhöt den Fehlerwert um 1
                eingabe[4]= 0,0,0,0;//Setzt die Eingabe wieder auf 0
            }
            //Alarm bei 3x falscher Passworteingabe
           if(fehler == 3)
           {//ALARM
           tone(4, 50, 1000);
            digitalWrite(7, LOW);
            delay(1000);
            tone(4, 50, 1000);
            digitalWrite(7, HIGH);
            delay(1000);
            tone(4, 50, 1000);
            digitalWrite(7, LOW);
            delay(1000);
            digitalWrite(7, HIGH);
            fehler = 0; //Alarm wider wieder auf 0  
           }
gedruckt = 0;//Zähler der gedrückten Tasten zurücksetzen       
}
}

Hallo,

entschuldige das sagen zu müssen, aber das ist leider völlig sinnlos was du machst.

Selbst wenn deine Endprüfung funktionieren würde, wäre die Reihenfolge der Tastendrücke komplett egal. Es findet keine Überprüfung der Reihenfolge statt. Du überprüfst nur ob 4x irgendeine Taste gedrückt wurde. Du kannst auch 4x die gleich drücken. Egal.

Deine Endpüfung ob code und Eingabe übereinstimmt klappt so nicht. Ist aber fast richtig, nimmst ja schon den index beider, vergleichst die aber nicht. Du müßtest 4x vergleichen ob test1 und test 2 gleich ist, denn da steht nur eine einzige Zahl drin zwischen 0 bis 4.

int code[4];
ist ein array, bestehend aus 4 Elementen auf die du mittels Indexnummer (0 bis 3) zugreifst.
Das ist keine zusammenhängende 4 stellige Zahl, die man einfach vergleichen könnte.

Edit:
du kannst diese aber zusammensetzen.

Summe = eingabe[0] * 1;        // *1 ist natürlich sinnlos, aber zur Verdeutlichung
Summe = Summe + eingabe[1] * 10;
Summe = Summe + eingabe[2] * 100;
Summe = Summe + eingabe[3] * 1000;

Dann prüfste ob Code von 1234 und Summe von 1234 gleich sind bzw. mußte das rumdrehen auf 4321.
Code ist dann kein array mehr sondern eine normale Zahl wie Summe auch.

Nochwas, lasse dir bei der Fehlersuche Zwischenwerte von Variablen auf die serielle ausgeben.
Das ist Debug für Arme, meistens völlig ausreichend.

Hi

Danke für deine Antwort:)

Habe den Code nun entsprechend angepasst.
Gebe ich nun den korrekten Code ein funktioniert alles.
Gebe ich aber etwas beliebig anderes ein passiert gar nichts.

//Knöpfe weleche gedrückt werden
int button1;
int button2;
int button3;
int button4;
int fehler = 0;
int summe = 0;
int code = 11110;
int gedruckt = 0;
boolean result;

void setup()
{
Serial.begin(9600);
//Inizialisierung der Schalter   
pinMode(13, INPUT);
pinMode(12, INPUT);
pinMode(11, INPUT);
pinMode(10, INPUT);

//LEDs
pinMode(7, OUTPUT);//Rote LED
pinMode(8, OUTPUT);//Grüne LED

//Lautsprecher
pinMode(4, OUTPUT);

//Setze das richtige Passwort


//Setze die Eingabe auf 0

}

void loop()
{   
    digitalWrite(8, HIGH);//Rote LED ist ein 
    digitalWrite(7, LOW);//Grüne LED ist aus
   
    //Benutzer eingabe B1
    if (digitalRead(13)==HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(13)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    summe = summe + 10;
    gedruckt++;   
    }

    //Benutzer eingabe B2
    if (digitalRead(12)==HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(12)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    summe = summe + 100;
    gedruckt++;
    }

    //Benutzer eingabe B3
    if (digitalRead(11)==HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(11)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    summe = summe + 1000;
    gedruckt++;
    }

    //Benutzer eingabe B4
    if (digitalRead(10)==HIGH) { do
                          {
                           delay(50); //Entprellen  
                          } while (digitalRead(10)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    summe = summe + 10000;
    gedruckt++;
    }
    
if(gedruckt == 4)//Überprüft ob 4 Tasten gedrückt worden sind 
{

   
            //Passwort Korrekt?
            //Setze die Variablen für den vergleich
            if (code == summe)
            {
            result = true;
            }
            else
            {
            result = false;
            }
 
           
            if(result == true)// Die Arrays sind gleich
            { 
            digitalWrite(8, LOW);     
            digitalWrite(7, HIGH);     
            tone(4, 500, 1000);     
            delay(5000);     
            digitalWrite(7, HIGH);
            digitalWrite(8, LOW);
            tone(4, 500, 1000);
            summe = 0;
            }
           
            if(result == false){ // Die Arrays sind ungleich
                digitalWrite(7, HIGH);//Rote LED ist ein 
                tone(4, 50, 1000);
                delay(50);
                fehler++;//Erhöt den Fehlerwert um 1
                summe = 0;
               
            }
            //Alarm bei 3x falscher Passworteingabe
           if(fehler == 3)
           {//ALARM
           tone(4, 100, 1000);
            digitalWrite(7, LOW);
            delay(1000);
            tone(4, 100, 1000);
            digitalWrite(7, HIGH);
            delay(1000);
            tone(4, 100, 1000);
            digitalWrite(7, LOW);
            delay(1000);
            digitalWrite(7, HIGH);
            fehler = 0; //Alarm wider wieder auf 0  
           }
gedruckt = 0;//Zähler der gedrückten Tasten zurücksetzen       
}
}

Hallo,

an das array willste nicht mehr ran?
Lass dir doch mal die summe und code in Zeile 76 auf die serielle ausgeben. Dann siehste was passiert.
Du hast nämlich immer noch eine Problem mit der Eingabe. Das ist nicht sicher genug.
Selbst wenn du nur die Tasten drückst die auch benötigt werden, bleibt die Endsumme gleich, auch wenn du diese in einer anderen Reihenfolge drückst.

Die Tasten benötigen eine feste Wertigkeit. Und die Druck Reihenfolge legt die Position im array Index fest.
Dann hat man beim drücken der Tasten 1,2,3,4 oder 2,4,3,1 unterschiedliche Endsummen.

Du hörst keinen Ton bei result == false? Im Moment auch ratlos, wenn das so wäre.
Deine LEDs ein/aus solltest du jedoch nochmal überrpüfen. Da ist was durcheinander geraten.

Hallo,

zum einfacheren debuggen habe ich dir das mal gebastelt.
Ich hoffe das hilft. Kannste abändern, erweitern, was weis ich.

Example_DebugMonitor_001.ino (1.23 KB)

Hi

Aha jetzt habe ich die Problematik mit meiner Eingabe verstanden^^

Jedoch habe ich keine Ahnung wie ich das in Code umsetzen könnte, so das die Reihenfolge der gedrückten Buttons gespeichert wird und am Schluss die Eingabe mit dem gesetzten Passwort verglichen werden kann.

Das Problem mit der LED konnte ich lösen, sie war defekt.

Ich habe die EIngabe von #7 genommen. Du speicherst in dem Array eingabe die Reihenfolge der Tastendrücke. Anschließend berechne ich die Lösungszahl summe in der for-schleife

void loop()
{   digitalWrite(7, HIGH);//Rote LED ist ein 
    digitalWrite(8, LOW);//Grüne LED ist aus

while (gedruckt<4) {   
    //Benutzer eingabe B1
    if (digitalRead(13) == HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(13)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=1;
    gedruckt++;    
    }

    //Benutzer eingabe B2
    if (digitalRead(12) == HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(12)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=2;
    gedruckt++;
    }

    //Benutzer eingabe B3
    if (digitalRead(11) == HIGH) { do
                          {
                           delay(50); //Entprellen 
                          } while (digitalRead(11)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=3;
    gedruckt++;
    }

    //Benutzer eingabe B4
    if (digitalRead(10) == HIGH) { do
                          {
                           delay(50); //Entprellen 
                          } while (digitalRead(10)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruck]=4;
    gedruckt++;
}     
}
int multi=1
for (int j=0; j=<3;j+=1 )
{
summe=summe+eingabe[j]*multi;
multi=multi*10;}

Hi

Danke für deine Antwort:)

Ich habe nicht ganz verstanden wie das mit eingabe[gedruckt]=3; funktioniert?

wie soll ich das deklarieren?

Gedruckt fängt bei 0 an und wird ja jeden Tastendruck weitergezählt. Also wird nach der Reihe in eingabe jeweils die Nummer der Taste eingespeichert. Beispiel: gedruckt=1; eingabe[gedruckt]=3; => Als zweite Taste wurde die 3 gedrückt und eingabe[1]=3 gesetzt.

Hi

Ich habe den Code nun angepasst und bekomme auch keinen Fehler beim kompilieren, jedoch passiert nun gar nichts mehr wenn ich die Tasten drücke.

//Knöpfe weleche gedrückt werden
int button1;
int button2;
int button3;
int button4;
int fehler = 0;
int summe = 0;
int code = 4321;
int gedruckt = 0;
boolean result;
int eingabe[3];

void setup()
{
Serial.begin(9600);
//Inizialisierung der Schalter   
pinMode(13, INPUT);
pinMode(12, INPUT);
pinMode(11, INPUT);
pinMode(10, INPUT);

//LEDs
pinMode(7, OUTPUT);//Rote LED
pinMode(8, OUTPUT);//Grüne LED

//Lautsprecher
pinMode(4, OUTPUT);

int eingabe[4];

//Setze die Eingabe auf 0


}

void loop()
{   
    digitalWrite(8, HIGH);//Rote LED ist ein 
    digitalWrite(7, LOW);//Grüne LED ist aus
   
while (gedruckt<4) {  
int gedruckt = 0; 
    //Benutzer eingabe B1
    if (digitalRead(13) == HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(13)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=1;
    gedruckt++;    
    }

    //Benutzer eingabe B2
    if (digitalRead(12) == HIGH) { do
                          {
                           delay(50); //Entprellen
                          } while (digitalRead(12)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=2;
    gedruckt++;
    }

    //Benutzer eingabe B3
    if (digitalRead(11) == HIGH) { do
                          {
                           delay(50); //Entprellen 
                          } while (digitalRead(11)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=3;
    gedruckt++;
    }

    //Benutzer eingabe B4
    if (digitalRead(10) == HIGH) { do
                          {
                           delay(50); //Entprellen 
                          } while (digitalRead(10)==HIGH);//Leerschleife solange die Taste gedrückt bleibt
    eingabe[gedruckt]=4;
    gedruckt++;
    }     
}
        int multi=1;
        int i;
        for( i = 0; i <= 3; i++)
        {
        summe=summe+eingabe[i]*multi;
        multi=multi*10;}

            //Passwort Korrekt?
            //Setze die Variablen für den vergleich
            if (code == summe)
            {
            result = true;
            }
            else
            {
            result = false;
            }
 
           
            if(result == true)// Die Arrays sind gleich
            { 
            digitalWrite(8, LOW);     
            digitalWrite(7, HIGH);     
            tone(4, 500, 1000);     
            delay(5000);     
            digitalWrite(7, HIGH);
            digitalWrite(8, LOW);
            tone(4, 500, 1000);
            summe = 0;
            }
           
            if(result == false){ // Die Arrays sind ungleich
                digitalWrite(7, HIGH);//Rote LED ist ein 
                tone(4, 50, 1000);
                delay(50);
                fehler++;//Erhöt den Fehlerwert um 1
                summe = 0;
               
            }
            //Alarm bei 3x falscher Passworteingabe
           if(fehler == 3)
           {//ALARM
           tone(4, 100, 1000);
            digitalWrite(7, LOW);
            delay(1000);
            tone(4, 100, 1000);
            digitalWrite(7, HIGH);
            delay(1000);
            tone(4, 100, 1000);
            digitalWrite(7, LOW);
            delay(1000);
            digitalWrite(7, HIGH);
            fehler = 0; //Alarm wider wieder auf 0  
           }
      

}
1 Like

Ich habe mal für jemanden ein solches Kodeschloss programmiert, vielleicht interessiert dich ja die Implementation.

Ohne großen Schnick-Schnack, nur mit 2 LEDs.

// https://github.com/thomasfredericks/Bounce2
#include <Bounce2.h>

// A four button code lock

// press 4 buttons in sequence
//  if the sequence matches the predefined sequence,
//   flash LED1 10 times (50ms on/50ms off), else lite LED2 for 1000ms
//  - feedback on sequence (start)

enum {
  noKey,
  oneKey,
  twoKeys,
  threeKeys,
  openLock,
  ignoreKeys,
  errorState
};

const byte buttons[] = {2, 3, 4, 5};
const byte ledPins[] = {6, 7};
const byte password[] = {0, 1, 0, 3};

Bounce keys[sizeof(buttons)];

const uint16_t de_Duration = 1000;

byte ds_Round;
uint32_t ds_Start;
uint16_t ds_currCycle;
const uint16_t ds_Repeats = 10;
const uint16_t ds_DurationOn = 20;
const uint16_t ds_DurationOff = 80;

byte state = noKey;
byte eatKeys;

void setup() {
  Serial.begin(115200);
  Serial.println(F("Keylock 4 keys, 2 leds"));
  for (byte idx = 0; idx < sizeof(buttons); idx++) {
    keys[idx].attach(buttons[idx], INPUT_PULLUP);
  }
  for (byte idx = 0; idx < sizeof(ledPins); idx++) {
    pinMode(ledPins[idx], OUTPUT);
  }
}

void startLedFlash(uint16_t reps, uint16_t firstBlink = ds_DurationOn) {
  ds_Round = reps;
  ds_Start = millis();
  ds_currCycle = firstBlink;
  digitalWrite(ledPins[0], HIGH);
}

bool keyCheck(byte idx, byte thenState) {
  bool ret = keys[password[idx]].fell();
  Serial.print(F(" key checked "));
  Serial.print(password[idx]);
  if (ret) {
    state = thenState;
    Serial.print(F(" ok"));
  } else {
    eatKeys = 3 - idx;
    state = ignoreKeys;
    Serial.print(F(" bad"));
    if (eatKeys) {
      Serial.print(F(", eat "));
      Serial.print(eatKeys);
    }
  }
  Serial.print(F(" next "));
  pState(state);
  return ret;
}

void loop() {
  static unsigned long timedStart;
  bool keyPress = false;

  for (byte idx = 0; idx < sizeof(buttons); idx++) {
    keys[idx].update();
    keyPress |= keys[idx].fell();
  }
  unsigned long topLoop = millis();
  if (keyPress || (state == errorState)) {
    if (keyPress) {
      Serial.print(F("key in "));
      pState(state);
      startLedFlash(1, 5);
    }
    switch (state) {
      case noKey:
        keyCheck(0, oneKey);
        break;
      case oneKey:
        keyCheck(1, twoKeys);
        break;
      case twoKeys:
        keyCheck(2, threeKeys);
        break;
      case threeKeys:
        if (!keyCheck(3, openLock)) {
          state = errorState;
          timedStart = topLoop;
          Serial.print(F(" last key bad, enter "));
          pState(state);
          break;
        }
        Serial.print(F("Fall into "));
        pState(state);
      case openLock:
        startLedFlash(ds_Repeats);
        state = noKey;
        Serial.print(F(" back to "));
        pState(state);
        break;
      case errorState:
        if (topLoop - timedStart > de_Duration) {
          state = noKey;
          Serial.print(F(" error time elapsed, back to "));
          pState(state);
        }
        break;
      case ignoreKeys:
        Serial.print(F(" to eat "));
        Serial.println(eatKeys);
        // was this the last key to eat?
        if (eatKeys-- == 1) {
          Serial.print(F(" last key consumed"));
          digitalWrite(ledPins[1], HIGH);
          timedStart = topLoop;
          state = errorState;
          Serial.print(F(" next "));
          pState(state);
        }
        break;
    }
  }

  // directly bind errorState to LED
  digitalWrite(ledPins[1], state == errorState);

  if (ds_Round != 0) {

    if (topLoop - ds_Start > ds_currCycle) {
      ds_Start = topLoop;

      // LED on ?
      if (digitalRead(ledPins[0])) {
        ds_currCycle = ds_DurationOff;
      } else {
        if (ds_Round-- != 1) {
          ds_currCycle = ds_DurationOn;
        } else {
          digitalWrite(ledPins[0], HIGH);
        }
      }
      digitalWrite(ledPins[0], !digitalRead(ledPins[0]));
    }

  }
}

size_t pStr_P(Print& p, const char *ptr) {
  size_t ret = 0;
  byte curr;
  while (curr = pgm_read_byte_near(ptr++)) {
    ret++;
    p.write(curr);
  }
  return ret;
}

void pStr_P(const char *ptr) {
  pStr_P(Serial, ptr);
}

void pStr_P(const char * const * pmPtr) {
  pStr_P(Serial, (const char*)pgm_read_ptr_near(pmPtr));
}

void pState(byte value) {
  static const char pmS0[] PROGMEM = "noKey";
  static const char pmS1[] PROGMEM = "twoKeys";
  static const char pmS2[] PROGMEM = "thwoKeys";
  static const char pmS3[] PROGMEM = "threeKeys";
  static const char pmS4[] PROGMEM = "openLock";
  static const char pmS5[] PROGMEM = "ignoreKeys";
  static const char pmS6[] PROGMEM = "errorState";
  static const char * const pmSTab[] PROGMEM = { pmS0, pmS1, pmS2, pmS3, pmS4, pmS5, pmS6 };
  pStr_P(&pmSTab[value]);
  Serial.println();
}

Einmal muss es heißen int eingabe[4];, da du 4 Elemente brauchst, der Index geht aber von 0-3.

In der Loop muss

while (gedruckt<4) {
int gedruckt = 0;

umgedreht werden, da gedruckt in der Schleife sonst immer null gesetzt wid.

da gedruckt in der Schleife sonst immer null gesetzt wid.

… da innnerhalb der Schleife eine neue unabhängige Variable ( mit dem Namengedruckt) definiert wird.
Das globalegedrucktwird nie verändert und loop bleibt ewig in der while Schleife hängen.

while Schleifen machen die Programmierung nur unnötig kompliziert, wenn sie nicht komplett falsch sind.
loop selbst ist dafür gedacht, die Schleife zu sein.