Viele if-Schleifen hintereinander

[mcb (Gast)]

Hallo,

ich bin gerade dabei, eine Abfrage für eine Tastatur zu schreiben. Die 
Funktion read_keypad_if soll dabei die Wertigkeit der Taste zurückgeben.
Funktion funktioniert, wenn man sie nur für zwei Tasten verwendet, also:

int debounce_if (const volatile uint8_t *debounce_if_port, uint8_t debounce_if_pin){
  if ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
    while ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
    }
    return 1;
  }
  return 0;
}

int read_keypad_if (void){
  if (debounce_if (&PIND, 5) == 1){ //Taste 1
    return 1;
  }
  if (debounce_if (&PINC, 1) == 1){ //Taste 2
    return 2;
  }
  return 0;
}

Wenn man allerdings alle Tasten miteinbezieht, wird gar keine Taste 
erkannt:

int debounce_if (const volatile uint8_t *debounce_if_port, uint8_t debounce_if_pin){
  if ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
    while ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
    }
    return 1;
  }
  return 0;
}

int read_keypad_if (void){
  if (debounce_if (&PIND, 5) == 1){ //Taste 1
    return 1;
  }
  if (debounce_if (&PINC, 1) == 1){ //Taste 2
    return 2;
  }
  if (debounce_if (&PINC, 5) == 1){ //Taste 3
    return 3;
  }
  if (debounce_if (&PIND, 4) == 1){ //Taste 4
    return 4;
  }
  if (debounce_if (&PINC, 0) == 1){ //Taste 5
    return 5;
  }
  if (debounce_if (&PINC, 4) == 1){ //Taste 6
    return 6;
  }
  if (debounce_if (&PIND, 3) == 1){ //Taste 7
    return 7;
  }
  if (debounce_if (&PIND, 7) == 1){ //Taste 8
    return 8;
  }
  if (debounce_if (&PINC, 3) == 1){ //Taste 9
    return 9;
  }
  if (debounce_if (&PIND, 2) == 1){ //Taste * = 10
    return 10;
  }
  if (debounce_if (&PIND, 6) == 1){ //Taste 0 = 11
    return 11;
  }
  if (debounce_if (&PINC, 2) == 1){ //Taste # = 12
    return 12;
  }
  return 0;
}

Aufruf und Auswertung im Hauptprogramm:

while (1){
    if (read_keypad_if () == 2){
      PORTA &= ~(1 << 5);
      _delay_ms (1000);
      PORTA |= (1 << 5);
    }
  }

Liegt das Problem bei den vielen if-Schleifen?

Danke im Voraus.

[if-Schleife (Gast)]

http://www.if-schleife.de/

[Lukas K. (carrotindustries)]

if-Schleife schrieb:
> http://www.if-schleife.de/

Das wollte ich auch schreiben :(
statt
>(debounce_if (&PIND, 5) == 1){
und
>if ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
schreibst du besser
(debounce_if (&PIND, (1<<5)) == 1){
und
if ((*debounce_if_port & debounce_if_pin) == 0){
Das kann der Compiler schon beim Kompilieren ausrechnen und der µC muss 
nichtmehr um n schieben, wofür es keine spezielle Instruktion gibt -> 
langsam

[Uhu U. (uhu)]

mcb schrieb:
> Liegt das Problem bei den vielen if-Schleifen?

Daß das keine Schleifen sind, wurde schon gesagt...

Nein, es liegt daran, daß du für jede if-Abfrage die debounce-Funktion 
ein weiteres mal aufrufst und die wartet, bis einen weiteres mal eine 
Taste gedrückt wurde.

[mcb (Gast)]

Die wartet doch nur, wenn eine Taste gedrückt wird, bis sie losgelassen 
wird.

[Yalu X. (yalu) (Moderator)]

Einmal abgesehen davon, dass die Funktion debounce_if entgegen ihrem
Namen die Taster nicht entrpellt, fällt mir an dem Programmstück nichts
Verdächtiges auf. Die paar if-Anweisungen hintereinander bringen den
Compiler nicht zum Verzweifeln.

Bist du sicher, dass während des Tests nicht die ganze Zeit Taster 1
geschlossen oder irgendwie überbrückt ist?

Die Taster schalten doch alle gegen GND und sind jeweils mit einem
Pullup-Widerstand (im Controller oder extern) versehen?

[Uhu U. (uhu)]

mcb schrieb:
> Die wartet doch nur, wenn eine Taste gedrückt wird, bis sie losgelassen
> wird.


Stimmt. Aber debouncen tut die Funktion auch nicht.

Zudem fragst du denselben Pin für verschiedene Tasten ab, z.B. 2 und 5.

[Ralph B. (rberres)]

Klärt mal einen Oberdau in Programmieren auf. Muss nicht nach jeder If 
Then else Abfrage ein End If folgen?
Zumindest kenne ich das von meinen HP-Instrumentbasic so.

Ralph Berres

[Uhu U. (uhu)]

Ralph Berres schrieb:
> Klärt mal einen Oberdau in Programmieren auf. Muss nicht nach jeder If
> Then else Abfrage ein End If folgen?

In C nicht.

[mcb (Gast)]

Ich frage dieselben PINs an unterschiedlichen PORTs ab! Siehe &PINC und 
&PIND!

[Daniel -. (root)]

solange die Taste nicht gedrückt wird, blockiert doch

  if ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
    while ((*debounce_if_port & (1 << debounce_if_pin)) == 0){
    }
    return 1;
  }

wenn man jetzt sukzessive die einzelnen Tasten abfragt, bleibt
man bei der ersten "gefangen" .. ganz unabhängig davon ob
die anderen gedrückt sind. Das ganze stellt doch eine Art
priorisierte Tastenabfrage dar. Ich verstehe ausserdem nicht
ganz warum dieselben Tasten mehrfach abgefragt werden.

[Daniel -. (root)]

mcb schrieb:
> Ich frage dieselben PINs an unterschiedlichen PORTs ab! Siehe &PINC und
> &PIND!

ah gütiger :)
was spricht dagegen so ein Schema anzuwenden

// PORTA Schalter
#define TASTE_LICHT 0
#define TASTE_MOTOR 1
...
#define TASTE_XYZ   7

// PORTB Schalter
#define TASTE_ABC 0
...
#define TASTE_SOUNDSO 7

der Programmcode muss "reden" ;)

[Uhu U. (uhu)]

Da die zweite Version von read_keypad_if sich von der ersten nur durch 
das unterscheidet, was nach der Abfrage der Taste 2 kommt, müssen beide 
Programme auf einen Druck der Taste 2 gleich reagieren.

Also funktionieren für die 2 entweder beide Versionen, oder keine.

[mcb (Gast)]

Zur allgemeinen Schaltinformation. Alle Taster der Tastatur sind mit den 
COM-Anschluss gegen GND geschalten. Die einzelnen PINs sind dann an die 
I/Os des Controllers angeschlossen. In der Software werden dann für 
diese PINs die internen Pull-Ups aktiviert. Bei der Funktion debounce_if 
wird abgefragt, ob die Taste gedückt ist. Wenn ja, wird gewartet, bis 
die Taste losgelassen wurde und dann 1 zurückgegeben, wenn nein, wird 0 
zurückgegeben.

[Daniel -. (root)]

soso, wenn das so ist, dann stimmt meine Argumentation von oben nicht.
Denn ich habe positive Logik angenommen .. 1=gedrückt

while (1){
    if (read_keypad_if () == 2){
      PORTA &= ~(1 << 5);
      _delay_ms (1000);
      PORTA |= (1 << 5);
    }
  }

Du erwartest nicht zufällig ein Blinken zur Bestättigung hier?

[mcb (Gast)]

Doch. Wenn die Taste 2 gedrückt wird, soll die LED kurz (1s) aufblinken. 
Das funktioniert ja auch beim 1.Fall (also nur mit den Tasten 1 und 2 in 
der Funktion). Beim 2.Fall aber nicht.

[Frank B. (frank501)]

Ich habe von C nun nicht gerade viel Ahnung, aber in den meisten 
richtigen Programmiersprachen gibt es die Case-Abfrage.
Wenn man nun die Taster einmal einliest und dann mit Case die 
Möglichkeiten abfragt dürfte das zumindest um einiges übersichtlicher 
sein.

Frank

[Daniel -. (root)]

mcb schrieb:
> Doch. Wenn die Taste 2 gedrückt wird, soll die LED kurz (1s) aufblinken.
> Das funktioniert ja auch beim 1.Fall (also nur mit den Tasten 1 und 2 in
> der Funktion). Beim 2.Fall aber nicht.

eine 0 bzw Löschen des Pines am PORT lässt die LED leuchten?
(kann gut sein, ohne schematic lässt sich das nicht ersehen)

hmm, was könnte noch als Ursache in Betracht kommen ...
eine Taste, die dauernd "an" (0) ist und die Abfragekette blockiert?
Dennoch, wenn das nicht gerade die erste Taste ist, sollten die
am Kopf der Abfragekette stehenden Tasten funkionieren.

mir ist übrigens die Übergabeform &PIND als Zeiger nicht bekannt.
ich glaube zwar, dass es so richtig ist, und volatile ist dein
Zeiger ja auch. Wenn ich gar nicht weiterwusste würde ich die Funktion
umschreiben .. ohne Zeiger und den Code einfach duplizieren, je
nach Port

int debounce_if (uint8_t port_id, uint8_t debounce_if_pin){
  switch(port_id) {
      case PORTD_ID:
        if ((PIND & (1 << debounce_if_pin)) == 0){
          while ((PIND & (1 << debounce_if_pin)) == 0);
          return 1;
        }
        return 0;
       case PORTC_ID: /* the same */
       default: return 0;
}

[Uhu U. (uhu)]

Schmeiß erst mal diese komische debounce_if raus - die funktioniert doch 
sowieso nicht.

Wenn du dann die Tasten bekommst, baust du eine Funktion, die wirklich 
entprellt.

[mcb (Gast)]

Ich habe mir nochmal den AVR-Tutorial Eintrag zur Tastenentprellung 
angesehen (siehe: 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#.28Tasten-.29Entprellung). 
Warum ist da die Funktion als inline deklariert?

[mcb (Gast)]

Ich hab jetz mal die Funktion wait (Nachfolger von debounce) durch 
das Aufblinken einer weiteren LED anzeigen lassen, dass die Taste 
gedrückt und wieder losgelassen wurde:

int wait(volatile uint8_t *wait_port, uint8_t wait_pin){
  if ((*wait_port & (1 << wait_pin)) == 0){
    while ((*wait_port & (1 << wait_pin)) == 0){
    }
    PORTA |= (1 << 4);
    _delay_ms (200);
    PORTA &= ~(1 << 4);
    return 1;
  }
  else return 0;
}

Lässt man nun beim Aufruf im Hauptprogramm (vorerst ohne Auswertung) die 
letzte Spalte der Tastatur (also Tasten 3, 6, 9, #) weg, und drückt dann 
irgendeine andere Taste, blinkt die LED auf:

int main (void){
  //DDRs definieren
  DDRA = 0b11111111;
  DDRB = 0b11111111;
  DDRC = 0b11000000;
  DDRD = 0b00000011;
  //PORTs definieren
  PORTA = 0b00000000;
  PORTB = 0b00000000;
  PORTC = 0b00111111; //interne Pull-ups für Tasten aktivieren
  PORTD = 0b11111100; //interne Pull-ups für Tasten aktivieren
  while (1){
    wait (&PIND, 5);
    wait (&PINC, 1);
    //wait (&PINC, 5);
    wait (&PIND, 4);
    wait (&PINC, 0);
    //wait (&PINC, 4);
    wait (&PIND, 3);
    wait (&PIND, 7);
    //wait (&PINC, 3);
    wait (&PIND, 2);
    wait (&PIND, 6);
    //wait (&PINC, 2);
  }
  return 0;
}

Ich kann mir nicht erklären, warum das nicht funktionieren sollte, die 
anderen Tasten auch abzufragen.

[Peter D. (peda)]

Erstmal Fusseln vom Mund wisch.

- Deine CPU stoppt komplett, solange eine Taste gedrückt ist

- Beim Loslassen macht sie dann noch nen Hickup von elendig langen 200ms 
(4 Millionen CPU-Zyklen).

- Die Reaktion erfolgt erst beim Loslassen. Ergonomisch wäre aber eine 
Reaktion beim Betätigen.


Falls Deine Programmnutzer mit diesen Nachteilen leben können und ein 
laienhaftes Feeling tolerieren, meinetwegen.


Peter

[mcb (Gast)]

So besser? Allerdings weiß ich nicht welchen Wert ich bei *_delay_ms 
(xx)* verwenden soll.

uint8_t debounce(const volatile uint8_t *debounce_port, uint8_t debounce_pin){
  if ((*debounce_port & (1 << debounce_pin)) == 0){
    _delay_ms (50);
    return 1;
  }
  return 0;
}

Aufruf und Auswertung auf die übliche Form:

if ((debounce (&PIND, 5) == 1)){ //PD5 =^ Taster 1
  //irgendetwas machen
}