Fragen zur Komfortroutine zum Entprellen

[dex (Gast)]

Hallo, bin seit einigen tagen fleißig am avr lernen und bin jetzt an 
dabei mich beim Taster Entrprellen einzuarbeiten. Für ein kleines 
Beispielprogramm habe ich die Komfortroutine aus dem Tut genommen und 
sie an mein Code angepasst. im prinzip funktioniert es, aber leider 
nicht so wie ich es haben will und mir fehlt da ein wenig das 
Verständnis für diese Routine.

Ich hab hier schon gelesen, dass der Algorithmus tricky und nur sehr 
schwer zu verstehen ist, aber wenn man diesen Code an seinen eigenen 
anpassen will, muss man schon etwas genauer wissen wie etwas 
funktioniert.

Meine schaltung ist wie folgt aufgebaut:

Verwendet wird ein Atmega8 mit einer LED an PB0 und PB1. Zusätzlich habe 
ich einen Taster an PD0 mit einem externen Pullup widerstand

Mein Code sind so aus

/*
 * TASTER_LED.c
 *
 * 
 * 
 */ 
#ifndef F_CPU
#define F_CPU           1000000                   // processor clock frequency
#warning kein F_CPU definiert
#endif
#define REPEAT_MASK     (1<<PD0 )                  // repeat: key1, key2
#define REPEAT_START    50                    // after 500ms
#define REPEAT_NEXT     20                   // every 200ms
#include <avr/io.h>
#include <avr/interrupt.h>


volatile uint8_t key_state;                                // debounced and inverted key state:
                               // bit = 1: key pressed
volatile uint8_t key_press;                   // key press detect
 
volatile uint8_t key_rpt;                                  // key long press and repeat
 
 
ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
 
  i = key_state ^ ~PIND;                       // 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
 
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }
}
 
///////////////////////////////////////////////////////////////////
//
// 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;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )
 
{
  key_mask &= key_state;
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
  cli();                                          // read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}
 
int main( void )
{
  PORTB = 0xFF;
  DDRB = 0xFF;                     
 
  DDRD  =0x00;                // configure key port for input
  PORTD =0x00;                // and turn on pull up resistors
 
  TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK |= 1<<TOIE0;                   // enable timer interrupt
 
  sei();
 
  while(1){
    if( get_key_short( 1<<PD0 ))
    PORTB ^= 1<<PB0;
 
 
   //  if( get_key_long( 1<<PD0 ))
  //  PORTB ^= 1<<PB1;
 
  
     
 
    
 
     //if( get_key_press( 1<<KEY2  get_key_rpt( 1<<KEY2 )){
       //uint8_t i = LED_PORT;
 
      //i = (i & 0x07) | ((i << 1) & 0xF0);
      //if( i < 0xF0 )
      //  i |= 0x08;
      //LED_PORT = i;      
    //}
  }
}

Jetzt zum Problem:

PORTB wird ja auf 0xFF gesetzt, das bedeutet, dass beide LEDs zu Beginn 
leuchten. Drücke ich den Taster, dann wird PORTB xor verknüpft und geht 
somit aus.
Jetzt möchte ich aber, dass die LED nicht ausgeht wenn ich den Taster 
drücke sondern dass sie angehen. Ich setze also PORTB=0x00 aber so 
funktioniert das nicht.

KAnn mir dann noch jemand erklären wofür der genau die key_repeat ist 
und wofür die dritte if abfrage in der while ist?

[Hilo (Gast)]

dex schrieb:
> Jetzt möchte ich aber, dass die LED nicht ausgeht wenn ich den Taster
> drücke sondern dass sie angehen.

Stichwort active-low und active-high

[dex (Gast)]

Danke für deine antwort,
aber beide Varianten haben keine Veränderung bewirkt