Zahlenschloss - Fehler

[Paul (Gast)]

Hallo,

ich arbeite gerade an einem Zahlenschloss und habe leider bereits einen 
Fehler im Code den ich einfach nicht verstehe..

In dem Code sollen einfach die gedrückten Taster abgefragt werden.

int PasswortArray[5] = {5,4,3,2,1};
 int PasswortArray2[5];


  int zahlhalter1=0;
  int zahlhalter2=0;
  int zahlhalter3=0;
  int zahlhalter4=0;
  int zahlhalter5=0;
  int zahlhalter6=0;

  int zaehler2=0;
  int zaehler=0;
  int test= 0;
  int pineins = 7;
  int pinzwei = 6; 
  int pindrei = 5;
  int pinvier = 4;
  int pinfuenf = 3;
  int pinsechs = 2;
  
  int prelltime=300;
  int program=0;
 
  int ledgruen =12;
  int ledrot=11;

  boolean result;
  
  
void setup() {
 
  pinMode(pineins, INPUT_PULLUP);
  pinMode(pinzwei, INPUT_PULLUP);
  pinMode(pindrei, INPUT_PULLUP);
  pinMode(pinvier, INPUT_PULLUP);
  pinMode(pinfuenf, INPUT_PULLUP);
  pinMode(pinsechs, INPUT_PULLUP);
  pinMode(ledrot, OUTPUT);
  pinMode(ledgruen, OUTPUT);
  Serial.begin(9600);
 
}

void loop() {
  
 
  //Delay um Taster zu entprellen
  
  
   do
        {  
        delay(100);    // warte darauf das Taster gedrückt wird
        }
        while((digitalRead(pineins) == LOW) && (digitalRead(pinzwei) == LOW) && (digitalRead(pindrei) == LOW) && (digitalRead(pinvier) == LOW));
 
   for(int i = 1; i < 6; i++){   
     
  if(digitalRead(pineins) == LOW) {
       //Entprellen
     zahlhalter1 =i;
    Serial.println("EINS");
    Serial.println(zahlhalter1);
        Serial.println(i);

    delay(prelltime);


      
  }   
      else if(digitalRead(pinzwei) == LOW) {
      zahlhalter2 =i;
      Serial.println("ZWEI");
      Serial.println(zahlhalter2);
      Serial.println(i);
            delay(prelltime);


  }
  
  else if(digitalRead(pindrei) == LOW) {
      zahlhalter3 =i;

      Serial.println("DREI");
      Serial.println(zahlhalter3);
              Serial.println(i);
      delay(prelltime);


  }
  
  else if(digitalRead(pinvier) ==LOW) {
      zahlhalter4 =i;
      Serial.println("VIER");
      Serial.println(zahlhalter4);
              Serial.println(i);
                    delay(prelltime);



  }
 

  }

 }

Ich bitte falsch deklarierte bzw. unnötige Variablen zu ignoieren ist ja 
alles noch in der Testphase :)

Das Problem im Code ist nun das als gedrückter Taster immer eins 
anzeigt, außer ich halte den Taster, dann zählt er brav bis vier hoch.

Woran liegts?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Paul schrieb:
> Woran liegts?
Am "else if"...

Wie sieht deine Hardware aus? Wie sind die Taster angeschlossen? Welches 
Signal gibt ein betätigter Taster ab?

Das mit dem Entprellen ist Murks. Und delay() ist MurksQuadrat.

Siehe den Beitrag "Arduino UNO | IF Schleife |"

[Paul (Gast)]

Warum am else if?


Also die Taster sind an die Pins 7-4 mit einem Pullup Widerstand 
angeschlossen. Taster LOW -->Aktion.


Wieso? Eingabe ist nicht zeitkritisch also warum soll ich die 
Debounce-Libary verwenden?


Lese den Link gerade.

[Karl H. (kbuchegg)]

Paul schrieb:

> Wieso? Eingabe ist nicht zeitkritisch also warum soll ich die
> Debounce-Libary verwenden?

Weil dein Zeugs ja wohl recht offensichtlich nicht vernünftig 
funktioniert. Sonst müsstest du ja nicht fragen.
Eine ordentlich und vernünftige Entprellung bzw. Erkennung eines 
Tastendrucks ist Voraussetzung für alles weitere. Egal wie die 
Flankenerkennung bzw. Entprellung dann tatsächlich realisiert ist. Aber 
funktionieren muss sie.

Und sowas

  do
        {  
        delay(100);    // warte darauf das Taster gedrückt wird
        }
        while((digitalRead(pineins) == LOW) && (digitalRead(pinzwei) == LOW) && (digitalRead(pindrei) == LOW) && (digitalRead(pinvier) == LOW));

ist noch viel größerer Murks. Selbst wenn der Kommentar zum Code stimmen 
würde.

Es wird nicht gewartet!
Deine loop() sieht als Pseudocode so aus

void loop()
{
  if Taste 1 gedrückt
    dann hänge eine 1 an die angegebene Kombination an

  else if Taste 2 gedrückt
    dann hänge eine 2 an die angegebene Kombination an

  else if Taste 3 gedrückt
    dann hänge eine 3 an die angegebene Kombination an


  if angegebene Kombination ist gleich der vorgegebenen Kombination
    dann öffne das Schloss
}

da wird nirgends gewartet. Alles was passiert ist: wenn ein Tastendruck 
festgestellt wird, dann wird dieser Tastendruck 'ausgewertet', indem die 
Zahl für die er steht an die bisherige Eingabe angehängt wird. Ist keine 
Taste gedrückt, dann passiert auch nichts weiter, bis loop() das nächste 
mal aufgerufen wird.

Weder muss es hier eine for-Schleife geben, die auf 6 Tasten wartet, 
noch muss man auf das Loslassen einer Taste warten. Denn letzteres macht 
die Erkennung eines Tastendrucks.
Und daher muss das Erkennen eines Tastendrucks (das Pedant zur 
Fragestellung_ ist jetzt gerade eine Taste gedrückt) absolut zuverlässig 
funktionieren. Und zwar auch für mehrere Tasten. Vorher hat es keinen 
Sinn darauf aufbauend irgendetwas weiterführendes zu programmieren.

[Paul (Gast)]

Was hat das delay mit dem restlichen Code zu tun? Nur weil er 300 ms 
wartet bis der Taster nicht mehr prellt...



Karl Heinz schrieb:
> Und sowas  do
>         {
>         delay(100);    // warte darauf das Taster gedrückt wird
>         }
>         while((digitalRead(pineins) == LOW) && (digitalRead(pinzwei) ==
> LOW) && (digitalRead(pindrei) == LOW) && (digitalRead(pinvier) == LOW));
> ist noch viel größerer Murks. Selbst wenn der Kommentar stimmen würde.
>
> Es wird nicht gewartet!

Warum soll nicht gewartet werden? Solange kein Taster gedrückt wird 
kommt er ja nicht weiter sondern wiederholt die Schleife solange bis ein 
Taster gedrückt wird..?



Okey, dann lasse ich die for-Schleife weg, aber wie überprüfe ich dann 
ob der Code welcher Eingegeben wurde auch der ist welcher im Array 
steht?

Der Code sollte später ebenfalls über die Taster neu programmiert werden 
können.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Paul schrieb:
> Warum soll nicht gewartet werden?
Weil damit Rechenzeit verplempert wird, die man irgendwann bitter nötig 
braucht. Oder frage dich mal andersrum: warum sollte gewartet werden? 
Lässt dich diese Aufgabe nicht ohne delay() lösen? Und bestenfalls "ganz 
unten", direkt an der Hardware kann es sein, dass man mal eine oder zwei 
us verplempern muss. Aber ein Delay im ms Bereich ist NIE nötig.


> Solange kein Taster gedrückt wird
Du bekommst es ja 300ms lang gar nicht mit, wenn da ein Taster gedrückt 
wird (nicht mal ein Wagnerscher Hammer prellt so lange). Du machst 
deinen uC absichtlich langsam und träge.


Du brauchst übrigens einfach eine "Flankenerkennung": ist eine Taste 
gedrückt worden, dann gibt es genau einen Durchlauf der Auswertung.

Ich werde das Morgen am Rechner mal kurz runterschreiben, hier am Handy 
ist mir das zu mühsam... ;-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

So, wie versprochen:

  // Pins definieren, dazu braucht man keine Variablen, 
  // denn Pins sind nicht variabel und hüpfen nicht wild hin und her...
  #define  pineins  7
  #define  pinzwei  6 
  #define  pindrei  5
  #define  pinvier  4
  #define  pinfuenf  3
  #define  pinsechs  2
  #define  ledgruen 12
  #define  ledrot 11
  
  int Code[5] = {5,4,3,2,1};
  int Schritt = 0;
  int Taste = 0;
  int Led = 0; // 1 = grün, 2= rot
  byte T1 = 0;
  byte T2 = 0;
  byte T3 = 0;
  byte T4 = 0;
  byte T5 = 0;
  byte T6 = 0;
  long tiAkt,tiEntprellen,tiLED,tiTimeoutEingabe;
 
void setup() {
 
  pinMode(pineins, INPUT_PULLUP);
  pinMode(pinzwei, INPUT_PULLUP);
  pinMode(pindrei, INPUT_PULLUP);
  pinMode(pinvier, INPUT_PULLUP);
  pinMode(pinfuenf, INPUT_PULLUP);
  pinMode(pinsechs, INPUT_PULLUP);
  pinMode(ledrot, OUTPUT);
  pinMode(ledgruen, OUTPUT);
}

void loop() {
   // Aktuelle Zeit abholen  
   tiAkt = millis();
   // Tasten einlesen
   if (digitalRead(pineins) == LOW)  T1 = 1; 
   else                              T1 = 0;
   :
   if (digitalRead(pinsechs) == LOW) T6 = 1; 
   else                              T6 = 0;
   
   // Tasten entprellen
   if (T1+T2+T3+T4+T5+T6 == 0) {    // keine Taste gedrückt 
     tiEntprellen = tiAkt+20;      // --> Entprelltimeout laufend hochzählen
     if (Schritt==0)
       tiTimeoutEingabe = tiAkt+10000000; // nach 10 sec Eingabe abbrechen
   }

   if (tiAkt > tiTimeoutEingabe ) { // Maximalzeit für Eingabe abgelaufen 
     Schritt=0;
     Led = 2; // rot
     tiLED = tiAkt+500;
   }

   if (tiAkt > tiEntprellen) {     // Entprellzeit abgelaufen --> Taste gültig
     tiEntprellen = tiAkt+1000;    // Repeatfunktion (kostenlos ;-)
     if (T1+T2+T3+T4+T5+T6 > 1) {  // zu viele Tasten gedrückt ?
       Schritt = 0;                // ja --> Abbruch Codeeingabe!! 
       Led = 2;                    // rote LED für 500ms einschalten
       tiLED = tiAkt+500;
     } else {                      // nein --> auswerten
       // Umrechnen Taste in Zahl
       Taste = 0;
       if (T1) Taste = 1;
       if (T2) Taste = 2;
       if (T3) Taste = 3;
       if (T4) Taste = 4;
       if (T5) Taste = 5;
       if (T6) Taste = 6;
       
       // Code vergleichen
       if (Taste == Code[Schritt]) { // passt?
         Schritt++;                  // ja --> Schritt hochzählen
       } else {                      // falsche Zahl
         Schritt = 0;                // --> Abbruch Codeeingabe!! 
         Led = 2;                    // rote LED für 500ms einschalten
         tiLED = tiAkt+500;
       }
    }  
  } // tiAkt>tiEntprellen

  if (Schritt == 5) {               // geschafft: Code komplett richtig eingegeben
    Schritt = 0;
    Led = 1;                        // grüne LED für 500ms einschalten
    tiLED = tiAkt+500;
  }
 
  if (tiAkt>tiLED) {                 // Zeit für LEDs abgelaufen?
        digitalWrite(ledrot,LOW);    // ja: LEDs aus
        digitalWrite(ledgruen,LOW); 
  } else {                  
        if (Led==1) digitalWrite(ledgruen,HIGH); // nein: richtige LED ein
        if (Led==2) digitalWrite(ledrot,HIGH);
  }
}

Könnte noch der eine oder andere Fehler drin sein, aber die grundlegende 
Idee dürfte klar werden...

[johann (Gast)]

Den Code würde ich erst nach Eingabe aller Zeichen vergleichen.
sonst sieht man sofort, wenn man einen Fehler gemacht hat...
Normalerweise hätte man die Sicherheit von 1 000 000 Möglichkeiten...
Signalisiert man den Fehler sofort, hat man nur noch max. 60 
Varianten...
Ansonsten sieht der Code für mich (als Anfänger) gut aus.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

johann schrieb:
> Den Code würde ich erst nach Eingabe aller Zeichen vergleichen.
> sonst sieht man sofort, wenn man einen Fehler gemacht hat...
Richtig. Kleine Anpassung nötig... ;-)

  int Code[5] = {5,4,3,2,1};
  int Codeeingabe[5];
  int Schritt = 0;
  int Treffer = 0;
  int Taste = 0;
   

  ...

      // Umrechnen Taste in Zahl
       Taste = 0;
       if (T1) Taste = 1;
       if (T2) Taste = 2;
       if (T3) Taste = 3;
       if (T4) Taste = 4;
       if (T5) Taste = 5;
       if (T6) Taste = 6;
       
       // Code abspeichern
       Codeeingabe[Schritt] = Taste);
       Schritt++;

    }  
  } // tiAkt>tiEntprellen
  
  if (Schritt == 5) {             // geschafft: Code prüfen
    for (Treffer=0, Schritt=0; Schritt<5; Schritt++) // einfach mal ansehen, wann was wie in der for-Schleife gemacht wird. Es lohnt sich... ;-)
       if (Code[i] = Codeeingabe[i]) Treffer++;

    if (Treffer==5) {             // alle Zahlen richtig
      Led = 1;                    // grüne LED für 500ms einschalten
      tiLED = tiAkt+500;
    } else {                      // falsche Zahl
      Schritt = 0;                 
      Led = 2;                    // rote LED für 500ms einschalten
      tiLED = tiAkt+500;
    }
  }
 
  if (tiAkt>tiLED) {                 // Zeit für LEDs abgelaufen?
   ...
}

Ich würde das Prüfen aber in der Realität mit einem memcmp() statt der 
for-Schleife machen...

[Peter D. (peda)]

johann schrieb:
> Den Code würde ich erst nach Eingabe aller Zeichen vergleichen.

Man kann auch sofort vergleichen und merkt sich einfach nur das 
Falschbit bis zur letzten Taste.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Peter Dannegger schrieb:
> Man kann auch sofort vergleichen und merkt sich einfach nur das
> Falschbit bis zur letzten Taste.
Tausende von Möglichkeiten...  ;-)

Da nehme ich wieder mal den ersten Code:

  int Code[5] = {5,4,3,2,1};
  int Schritt = 0;
  int Falscheingabe = 0;
  int Taste = 0;
  int Led = 0; // 1 = grün, 2= rot

  ...

   // Tasten entprellen
   if (T1+T2+T3+T4+T5+T6 == 0) {    // keine Taste gedrückt 
     tiEntprellen = tiAkt+20;       // --> Entprelltimeout laufend hochzählen
     if (Schritt==0) {              // noch nicht angefangen?
       Falscheingabe = 0;
       tiTimeoutEingabe = tiAkt+10000000; // nach 10 sec Eingabe abbrechen
     }
   }

   if (tiAkt > tiTimeoutEingabe ) { // Maximalzeit für Eingabe abgelaufen 
     Schritt = 0;
     Led = 2; // rot
     tiLED = tiAkt+500;
   }

   if (tiAkt > tiEntprellen) {     // Entprellzeit abgelaufen --> Taste gültig
     tiEntprellen = tiAkt+1000;    // Repeatfunktion (kostenlos ;-)
     if (T1+T2+T3+T4+T5+T6 > 1) {  // zu viele Tasten gedrückt ?
       Schritt = 0;                // ja --> Abbruch Codeeingabe!! 
       Led = 2;                    // rote LED für 500ms einschalten
       tiLED = tiAkt+500;
     } else {                      // nein --> auswerten
       // Umrechnen Taste in Zahl
       Taste = 0;
       if (T1) Taste = 1;
       if (T2) Taste = 2;
       if (T3) Taste = 3;
       if (T4) Taste = 4;
       if (T5) Taste = 5;
       if (T6) Taste = 6;
       
       // Code vergleichen
       if (Taste != Code[Schritt]) // Falscheingabe?
         Falscheingabe++;          // ja: merken!

       Schritt++;                  // Nächste Zahl: Schritt hochzählen
    }  
  } // tiAkt>tiEntprellen

  if (Schritt == 5) {               // geschafft: 5 Zahlen eingegeben
    Schritt = 0;
    if (Falscheingabe==0)           // Falscheingabe?
      Led = 1;                      // nein: grüne LED einschalten
    else 
      Led = 2;                      // ja: rote LED einschalten
    tiLED = tiAkt+500;              // für 500ms 
  }
 
  if (tiAkt>tiLED) {                 // Zeit für LEDs abgelaufen?
  ...
}

[Peter D. (peda)]

Paul schrieb:
> Wieso? Eingabe ist nicht zeitkritisch also warum soll ich die
> Debounce-Libary verwenden?

Eine separate Tastenfunktion mit Entprellung und Flankenerkenung macht 
aber das Programmieren erheblich einfacher.
Man braucht dann nur noch den eigentlichen Ablauf zu programmieren.

[Karl H. (kbuchegg)]

Ich würde ehrlich gesagt gar keine Möglichkeit zum Abbruch der 
Codeeingabe vorsehen.

Der Benutzer tippt einfach dahin. Die letzten 5 eingegebenen Ziffern 
gelten (werden mit jeder Benutzereingabe um 1 Stelle weitergeshiftet, 
die am 5-weitesten zurück liegende Eingabe fällt raus).
Stimmen zu irgendeinem Zeitpunkt alle 5 Ziffern, wird die LED grün, 
ansonsten rot.

D.h. wenn sich ein Benutzer mal vertippt, dann fängt er einfach erneut 
mit der Eingabe der 6 Ziffern an, egal wieviele Stellen er schon 
eingegeben hat. Ist das Schloss geöffnet, dann braucht er einfach nur 
irgendeine Ziffer tippen (vernünftiger Code vorausgesetzt) und das 
Schloss ist wieder geschlossen.
Ein 'Einbrecher' erhält dadurch keinerlei Information. Weder über 
gültige Ziffern noch über die Codelänge.

void loop()
{
  .... Tastenerkennung ....

  if( Tastedruck registriert ) {
    for( i = 0; i < 4; i++ )
      Codeeingabe[i] = Codeeingabe[i+1];
    Codeeingabe[4] = nächster Tastendruck;

    Treffer = TRUE;
    for( i = 0; i < 5; i++ ) {
      if( Codeeingabe[i] == Code[i] )
        Treffer = FALSE;
    }

    digitalWrite(ledrot, Treffer ? HIGH : LOW);
    digitalWrite(ledgruen, Treffer ? LOW : HIGH );
  }
}

Ich hätte auch die Tastenerkennung/Enprellung einfacher gemacht. Da hier 
wohl niemand nur ganz kurz antippen wird, hätte ich einfach eine 
Flankenerkennung alle 50ms gemacht. 50ms dürfte ausreichen, um 
eventuelles Prellen zu eliminieren und wenn nicht, dann geht man eben 
mit der Zeit noch etwas hoch.


So ungefähr

...
uint8_t oldState[10];
uint8_t stateNow[10];
uint8_t keyPressed;
uint8_t isValid;
unsigned long lastCheckedTime ;

uint8_t pinNr[10] = { pinEins, pinZwei, pinDrei, .... };

#define CODE_LEN 5
uint8_t Code[CODE_LEN] = {5,4,3,2,1};
uint8_t Codeeingabe[CODE_LEN];

....

void loop()
{
  keyPressed = -1;

  // alle 50ms den Zustand der Tasten checken und auswerten
  if( millis() - lastCheckedTime > 50 ) {
    lastCheckedTime = millis();

    // 10 Tasten abfragen
    // gab es an irgendeinem Pin eine Veränderung?
    // Bei exakt gleichzeitiger Betätigung ist die Priorität
    // in aufsteigender Reihung 1, 2, 3, 4, 5, 6, 7, 8, 9, 0

    for( i = 0; i < 10; i++ ) {
      stateNow[i] = digitalRead( pinNr[i] );
      if( stateNow[i] != oldState[i] && stateNow[i] == LOW )
        keyPressed = i;
      oldState[i] = stateNow[i];
    }
  }

  // wurde irgendeine Taste in der Zwischenzeit niedergedrückt?
  if( keyPressed != -1 ) {
    // bisherigen Code um 1 Stelle weiter schieben und Tstendruck
    // hinten anhängen
    for( i = 0; i < CODE_LEN-1; i++ )
      Codeeingabe[i] = Codeeingabe[i+1];
    Codeeingabe[CODE_LEN-1] = keyPressed;

   // ergibt sich dadurch ein gültiger Code ....
   isValid = TRUE;
    for( i = 0; i < CODE_LEN; i++ ) {
      if( Codeeingabe[i] == Code[i] )
        isValid = FALSE;
    }

    // ... die LEDs entsprechend der Gültigkeit schalten
    digitalWrite(ledrot, isValid ? HIGH : LOW);
    digitalWrite(ledgruen, isValid ? LOW : HIGH );
  }
}

[JH (Gast)]

Karl Heinz schrieb:
> Ich würde ehrlich gesagt gar keine Möglichkeit zum Abbruch der
> Codeeingabe vorsehen.
>
> Der Benutzer tippt einfach dahin. Die letzten 5 eingegebenen Ziffern
> gelten (werden mit jeder Benutzereingabe um 1 Stelle weitergeshiftet,
> die am 5-weitesten zurück liegende Eingabe fällt raus).
> Stimmen zu irgendeinem Zeitpunkt alle 5 Ziffern, wird die LED grün,
> ansonsten rot.

Das würde ich nicht machen. Ist der Code bspw. 00001 und der Einbrecher 
probiert zuerst 10000, dann braucht er danach nur noch einmal die Eins 
drücken (will z.B. als nächstes 10001 probieren) und schon hat er den 
Code.

[Karl H. (kbuchegg)]

JH schrieb:
> Karl Heinz schrieb:
>> Ich würde ehrlich gesagt gar keine Möglichkeit zum Abbruch der
>> Codeeingabe vorsehen.
>>
>> Der Benutzer tippt einfach dahin. Die letzten 5 eingegebenen Ziffern
>> gelten (werden mit jeder Benutzereingabe um 1 Stelle weitergeshiftet,
>> die am 5-weitesten zurück liegende Eingabe fällt raus).
>> Stimmen zu irgendeinem Zeitpunkt alle 5 Ziffern, wird die LED grün,
>> ansonsten rot.
>
> Das würde ich nicht machen. Ist der Code bspw. 00001

Ich vergass:
vernünftigen Code vorausgesetzt

> danach nur noch einmal die Eins drücken (will z.B. als nächstes
> 10001 probieren) und schon hat er den Code.

Ja, wenn.
Dazu muss er aber wissen, dass der Code 5 stellig ist. Da ihm aber das 
Gerät diese Information nicht verrät, ergibt sich da ein zusätzlicher 
Schutz, den es mit der Alternative nicht gibt.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Karl Heinz schrieb:
> digitalWrite(ledrot, isValid ? HIGH : LOW);
Den Fragezeichenoperator wollte ich erst in der nächsten Stunde 
drannehmen... ;-)

> isValid
Das allein wäre mir zu wenig. Da bleibt der Türöffner ja bis zur 
nächsten Eingabe betätigt...

> Ich würde ehrlich gesagt gar keine Möglichkeit zum Abbruch der
> Codeeingabe vorsehen.
Ich würde im Gegenteil die Codeeingabe frühestmöglich abbrechen: nur ein 
zügig eingegebener Code ist ein gültiger Code. Wenn so eine zögerliche 
Eingabe erkannt und gespeichert, aber nicht angezeigt wird, dann 
probiert man sogar mit der richtigen Nummer herum, ohne dass die Tür 
aufgeht: nach holpriger Eingabe der richtigen Zahl leuchtet die rote 
LED... :-o

[Karl H. (kbuchegg)]

Lothar Miller schrieb:
> Karl Heinz schrieb:
>> digitalWrite(ledrot, isValid ? HIGH : LOW);
> Den Fragezeichenoperator wollte ich erst in der nächsten Stunde
> drannehmen... ;-)

:-)

>
>> isValid
> Das allein wäre mir zu wenig. Da bleibt der Türöffner ja bis zur
> nächsten Eingabe betätigt...

OK. Häng noch ein Software Monoflop hinten nach.
Ausserdem: Es ist das Projekt des TO. Was bleibt denn noch für ihn zu 
tun, wenn wir ihm alles erledigen :-)

Ich hab in letzter Zeit sowieso schon so meine persönlichen Probleme mit 
Projekten der Marke "Ich will ein Space Shuttle bauen ... aber ich kann 
noch nicht mal einen Papierflieger falten ... ich will es auch nicht 
lernen .... könnt ihr nicht mal .... guck mal Mama, was ICH gebaut habe"

>
>> Ich würde ehrlich gesagt gar keine Möglichkeit zum Abbruch der
>> Codeeingabe vorsehen.
> Ich würde im Gegenteil die Codeeingabe frühestmöglich abbrechen: nur ein
> zügig eingegebener Code ist ein gültiger Code. Wenn das nicht angezeigt
> wird, dann probiert man sogar mit der richtigen Nummer herum, ohne
> dass die Tür aufgeht...

Auch eine nette Alternative. Lässt sich (genauso wie bei dir) auch in 
meinem Schema problemlos nachrüsten. 5 Sekunden nach dem letzten 
Tastendruck, werden alle Stellen zwangsweise zb auf 0 gesetzt. Zeit des 
letzten Tastendrucks merken, Differenzbildung von millis() und wenn 
größer 5000 läuft die Rücksetzmaschinerie. Je mehr ich darüber 
nachdenke, desto besser gefällt mir diese Zeitbegrenzung.

[JH (Gast)]

Karl Heinz schrieb:
> Ja, wenn.
> Dazu muss er aber wissen, dass der Code 5 stellig ist. Da ihm aber das
> Gerät diese Information nicht verrät, ergibt sich da ein zusätzlicher
> Schutz, den es mit der Alternative nicht gibt.

Karl Heinz schrieb:
> Ich vergass:
> vernünftigen Code vorausgesetzt

Wenn man das Schloss möglichst sicher machen möchte, dann sollte es 
keinen "vernünftigeren" Code geben :P

Karl Heinz schrieb:
> Ja, wenn.
> Dazu muss er aber wissen, dass der Code 5 stellig ist. Da ihm aber das
> Gerät diese Information nicht verrät, ergibt sich da ein zusätzlicher
> Schutz, den es mit der Alternative nicht gibt.

Wenn er nicht weiß, dass der wielang der Code ist, bleibt ihm ja nur 
alle Längen durchzuprobieren. Angenommen der Code sei dreistellig -> 
930. Er probiert also erstmall alle einstelligen Codes (0..9) ohne 
Erfolg. Jetzt startet er mit der Eingabe aller zweistelligen Codes 
(00..99) und öffnet das Schloss bereits bei der Eingabe von "30", da er 
vorher "29" probiert hat.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Karl Heinz schrieb:
> Auch eine nette ALternative.
Man könnte noch eins weiter gehen und die Zahlen komplett irrelevant 
machen. Dann gilt nur der Rhythmus der Tastaturbetätigungen. Ist 
natürlich nichts für Schlagzeuger, die schleppen gern... ;-)

[Karl H. (kbuchegg)]

JH schrieb:

> Wenn er nicht weiß, dass der wielang der Code ist, bleibt ihm ja nur
> alle Längen durchzuprobieren. Angenommen der Code sei dreistellig ->
> 930. Er probiert also erstmall alle einstelligen Codes (0..9) ohne
> Erfolg. Jetzt startet er mit der Eingabe aller zweistelligen Codes
> (00..99) und öffnet das Schloss bereits bei der Eingabe von "30", da er
> vorher "29" probiert hat.

Sperr ihm die Eingabe nach der 5-ten Falscheingabe für 2 Minuten und der 
sitzt die ganze Nacht am Gerät um die 40 Eingaben zu machen. Ausserdem 
ist der Code nicht 3-stellig sondern 5 stellig (was aber ein Einbrecher 
nicht weiß).
Klar kann es passieren, dass er durch Zufall die richtige Kombination 
bekommt. Das kann im anderen Fall aber genau so passieren. Nur mit dem 
Unterschied, dass er mit dem Wissen des 5 stelligen Codes erst mal alle 
Geburtsdaten durchprobiert, den Hochzeitstag, etc. etc.

Aber ok.
Ich sag ja nicht, dass er muss. So würde ich das machen. Wenn ihm das 
nicht gefällt, kann er immer noch eine Rücksetztaste dazu bauen und die 
Anzahl der Tastendrücke mitzählen. Schliesslich sind wir Programmierer. 
Wir bestimmen, wie sich die Dinge verhalten sollen und so wie wir das 
definieren ist es per Definition richtig :-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Karl Heinz schrieb:
> Sperr ihm die Eingabe nach der 5-ten Falscheingabe für 2 Minuten und der
> sitzt die ganze Nacht am Gerät um die 40 Eingaben zu machen.
Ich würde in diesem Fall während der (unsichtbaren) Sperrzeit nach 
irgendeinem Tastendruck beliebig mal die rote oder die grüne LED ein- 
und wieder ausschalten (natürlich ohne den Türöffner zu betätigen)... 
;-)

> so wie wir das definieren ist es per Definition richtig :-)
Und das ist gut so.
Der Trick dabei ist: der uC muss das machen, was wir wollen. Und das 
können wir ihm mit einfachen und strukturierten Anweisungen sagen.
Ein delay() trägt aber niemals etwas zur Struktur bei. Ein delay() 
verzögert bestenfalls irgendwelche Probleme, ist aber oft sogar die 
Ursache dafür...

[Frank M. (ukw) (Moderator)]

Wenn man einbaut, dass man immer zwei aufeinanderfolgende Ziffern 
paarweise gleichzeitig drücken muss, kann man den Code sogar noch 
ausdrucken und als Gedächtnisstütze direkt neben das Schloss kleben ;-)

[kopfkratzer (Gast)]

kopfkratz
Man könnte natürlich auch eine Tastenkombination als Auslöser nehmen, 
z.B. 0+9 gleichzeitig gedrückt testet ob der Code korrekt war ...
Oder man schafft sich ein paar nette Rottweiler an, die riechen's dann 
:-P

[Nosnibor (Gast)]

Karl Heinz schrieb:
> Ich würde ehrlich gesagt gar keine Möglichkeit zum Abbruch der
> Codeeingabe vorsehen.
>
> Der Benutzer tippt einfach dahin. Die letzten 5 eingegebenen Ziffern
> gelten (werden mit jeder Benutzereingabe um 1 Stelle weitergeshiftet,
> die am 5-weitesten zurück liegende Eingabe fällt raus).
> Stimmen zu irgendeinem Zeitpunkt alle 5 Ziffern, wird die LED grün,
> ansonsten rot.

Der Nachteil dabei ist, daß der Angreifer mit jedem Tastendruck eine 
neue Kombination testen kann, was das Durchprobieren beschleunigt.

Die einfachste Abhilfe wäre eine zusätzliche Taste, mit der der Benutzer 
sagt, daß er jetzt fertig ist, und der Code geprüft werden soll.

Alternativ könnte man sich einen cleveren Sperrzeit-Algorithmus 
ausdenken, aber man muß dabei berücksichtigen, daß jede korrekte Eingabe 
eines fünfstelligen Codes erstmal mit vier falschen Eingaben anfängt.

[Paul (Gast)]

Ich danke euch für die zahlreichen Antworten :)
Habe nun durch die Tipps meine eigenen Code geschrieben und es 
funktioniert.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Paul schrieb:
> Habe nun durch die Tipps meine eigenen Code geschrieben
Trau dich doch einfach, den Code hier zu posten. Andere könnten etwas 
davon lernen...