Peter Daneggers Entprellung auf activ high

[Florian Dussinger (Gast)]

Hallo,

ich habe eigentlich kein Problem, das Programm läuft. Ich vermute nur 
einen kleinen Wackler auf dem Breadboard, da von 40 Tastendrücke ca. 1 
nicht erkannt wird. Es wäre dennoch schön, wenn jemand mal kurz drüber 
schauen könnte.
Ich habe den Code aus dem Tutorial von Peter Danegger abgespeckt und auf 
active high umgebaut.
Prozessor: Atmega8
Timer2 im CTC auf 1ms eingestellt (da ich später im 1ms Rythmus polle 
mit diesem Timer)
Die Routine reagiert nur auf Tastendrücke, keine Repeats, keine langen 
Drücke, also ziemlich abgespeckt und nur für einen Eingang/Taster.
Vielleicht kann jemand den Code auch brauchen, wenn er einen aktiv high 
Taster entprellen möchte.
Wollte nur nochmal kurz eine Bestätigung, ob das so ok ist.
Im Prinip habe ich nur diese Zeile verändert für activ high:

i = key_state ^ ~KEY_PIN; 
//zu dieser
i = key_state ^ KEY_PIN;

Hier mein Code:

/****************************************************************************/
/*                                      */
/*        Programm LED und Taster  aktiv high              */
/*                                      */
/****************************************************************************/

#ifndef F_CPU
#define F_CPU           8000000                  // processor clock frequency 8Mhz
#warning kein F_CPU definiert
#endif                 

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

#define LED    PB1        //Pin der LED
#define PIN_Taster    PINB
#define Taster  PB0

// ----------------------------------------------------------------------------
// Funktionsdeklarationen
// ----------------------------------------------------------------------------
void init(void);
uint8_t get_key_press( uint8_t key_mask );


// ----------------------------------------------------------------------------
// globale Variablen für Interrupts (volatile)
// ----------------------------------------------------------------------------
volatile uint8_t key_state;                                // debounced and inverted key state:
                              // bit = 1: key pressed
volatile uint8_t key_press;                                // key press detect
volatile unsigned short millisekunden = 0;
volatile unsigned short entprellzeit = 0;



//Timer2 Comapre Match Interrupt CTC
ISR(TIMER2_COMP_vect)                           // every 1ms
{
  millisekunden++;      // wird für späteres pollen benötigt
  entprellzeit++;
    if (entprellzeit == 10){          // every 10ms
    static uint8_t ct0, ct1;
    uint8_t i;
   
    entprellzeit = 0;                // Entprellzeit wieder zurücksetzen
   
    i = key_state ^ PIN_Taster;                // key changed ?
    ct0 = ~( ct0 & i );                             // reset or count ct0
    ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
    i &= ct0 & ct1;                                 // count until roll over ?
    key_state ^= i;                                 // then toggle debounced state
    key_press |= key_state & i;                     // 0->1: key press detect
    
    }
}

//Das Hauptprogramm
int main()
{
  
  TCCR2 = (1<<CS22) | (1 << WGM21);  // Prescaler 64, CTC Clear on Compare Match
   OCR2 = 124;         // jede 1ms tritt ein Compare Match Interrupt auf        
  TIMSK |= (1<<OCIE2);   // Timer Compare Match Enable
  
  DDRB = 0x00;      //Datenrichtungsregister zunächst alle Eingang 
  DDRB |= (1 << DDB1);   //PB1 als Ausgang schalten für LED
  PORTB = (1 << PB1);  //LED aus
  
   sei();  
  
  while(1)
  
  
  //Zustand des Tasters abfragen mit Entprellfunktion
  if (get_key_press( 1<<Taster )){
    
    if (!(PINB & (1<<LED))){    //LED war an
    PORTB |= (1 << LED);  //LED ausschalten
  
    }
    
    else {
    PORTB &=~ (1 << LED);    //LED anschalten
    }
  }

}

// Funktionen
///////////////////////////////////////////////////////////////////
// by Peter Danegger
// check if a key has been pressed. Each pressed key is reported
// only once
///////////////////////////////////////////////////////////////////
uint8_t get_key_press( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  sei();
  return key_mask;
}