Taster entprellen

[Judgin F. (einsteiger777)]

Hallo Leute,

ich habe eine Frage bezüglich Tastenentrpellung!
Ich habe es geschafft, einen LED ein und auszuschalten.
Jetzt will ich mit einem zweiten Taster (z.B. PD2) die LED umschalten, 
auch wenn der andere Taster (PD3) noch gedrückt war.
Ich bin auf dem Schlauch und weiß nicht genau, wo und welchen Code ich 
einfügen soll!

Kann jemand weiterhelfen?

Hier mein bisheriger Code:

/***************************************/
/*   AVR Board1  TasterEntprellung    */
/*  Demo mit Wechselschalter         */
/*  Penningsfeld                     */
/*  Christoph Arndt                  */
/*  Start: 26. März 2011             */
/*  CPU  Atmel 168                   */
/*  MODULE TasterEntprellung.c       */
/*  Taster einmal drücken            */
/*  Leuchtdiode  an/aus              */
/*-------------------------------------*/
#include <avr/io.h>
//------------------------------  HARDWARE ---------------
#define LED_Bit 0x08  // Bitadresse
#define LED_PORT PORTC  // PORT Ausgaberegister
#define LED_DDR DDRC    // PORT Data Direction Register
            // Taster an PIN: Port IN
#define Taster_Bit 0x08  // Bitadresse
#define Taster_PIN PIND  // PIN Port Input
#define Taster_DDR DDRD  // Data Direction Register
//------------------------- Variable ----------------
unsigned char Taster_input;  // Port Bit Taster 
//eingelesen: gedrückt=1
              //      nicht gedrückt=0
unsigned char count;    // inkrementieren, wenn
            // Taster_input=1
unsigned char pressed;  // =1, wenn Taster
            // nach Entprellung gedrückt
unsigned char old_pressed; // Merker für
             // Zustandswechsel
unsigned char pos_edge; // Zähler für Flanken
#define count_min 100   // Taktraster
//----------------------------------------------------
// Data Direction-Bit 0: input, 1: output
// All LEDs are open Collector Outputs => 0 is LED on
//----------------------------------------- main -----
int main (void)
{             // PIN Configuration
  LED_PORT = LED_PORT | LED_Bit;// LED aus
  LED_DDR = LED_DDR | LED_Bit;   // Direction: LED Bit:
              // 1=output
  Taster_DDR = Taster_DDR & ~Taster_Bit;
          // Direction: Taster Bit: input
  pressed = 0;
  old_pressed = 0;
  pos_edge = 0;
  unsigned char temp_taster;
  while (1)
    {  // ----- Taster Eingang -----------------------
    temp_taster = Taster_PIN;
    if (temp_taster & 0x04 || temp_taster & 0x08)
      { Taster_input = 0;
      }
    else
      { Taster_input = 1;
      }
    // ---- Zustandsautomat für Entprellung -------
    if (Taster_input)      // wenn Taster gedrueckt
      {if ((!pressed) && (count < count_min))
        {      // und noch nicht
          count++;  // entprellt
          if (count == count_min)
          { pressed = 1; // gedrückt
                // erkannt
          }
        }
       if (pressed == 1) count = count_min;
        // count rücksetzen, wenn Taste prellt
      }
    else        // Taster nicht gedrückt
      {if ((pressed) && (count > 0))
        { count--;  // und nicht
              // entprellt
          if (count == 0)
          { pressed = 0; // nicht gedrückt
          }             // erkannt
        }
       if (pressed == 0) count = 0;
        // count rücksetzen, wenn Taste prellt
      }
    // ----- Zustandsautomat für Flankenerkennung ------
    if ((pressed == 1) && (old_pressed == 0))
      {pos_edge++;    // hier nur inkrementieren
      }
    old_pressed = pressed;
    //----- Auswertung ---------------------------------
    if (pos_edge)      // wenn neu gedrückt > 0
      {if (LED_PORT & LED_Bit)      // Umschalten
         {LED_PORT = LED_PORT & ~LED_Bit;// LED an
         }
       else
        {LED_PORT = LED_PORT | LED_Bit;   // LED aus
        }
        pos_edge--;  // so kann keine Flanke
            // verlorengehen
      }
    }  // end while
}     //------- end main ---------------------------------

[Karl H. (kbuchegg)]

Meine ehrliche Meinung:
Diese Entprellung taugt nicht viel.
Nicht weil sie nicht entprellen würde, ich glaube dir, dass sie das tut. 
Aber softwaretechnisch ist sie schlecht, weil sie nicht in dem Sinn 
modular ist, dass du sie in eine Funktion auslagern kannst. Das ist 
zuviel Geplänkel in der Hauptschleife, durch das man sich erst mal 
durchsuchen muss um die relevanten Informationen zu finden.

Sieh dir das hier an
Entprellung

Hier findest du Entprellungen, die besser aufgebaut sind. Vor allen 
Dingen die letzte auf dieser Seite eignet sich gut für alle in der 
Praxis vorkommenden Fälle. Und mit ihr ist auch das was du vorhast kein 
Problem.