Probleme mit Tastenentprellung get_key_short/get_key_long

[Manfred Daret (Gast)]

Hallo,

ich verwende folgenden Code auf einem Atmega8:

// ----------------------------------------------------------------------------
// INCLUDES
// ----------------------------------------------------------------------------

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


// ----------------------------------------------------------------------------
// DEFINES
// ----------------------------------------------------------------------------
#ifndef F_CPU
#define F_CPU           8000000UL                   // processor clock frequency 8Mhz
#endif

#define REPEAT_START    41                       
#define REPEAT_NEXT     83

#define LED      PD3    

// Port Defines
#define PORTLED    PORTD

// --------------------------------------------------------------------------------------------
// Funktionsdeklarationen
// --------------------------------------------------------------------------------------------
void init_ports(void);     // Initialisiert die Ports, Enable global Interrupt
void init_timer1(void);   // Initialisiert den Timer1 16-bit

uint8_t get_key_press_PIND_high( uint8_t key_mask );
uint8_t get_key_state_PIND_high( uint8_t key_mask );
uint8_t get_key_rpt_PIND_high( uint8_t key_mask );
uint8_t get_key_short_PIND_high( uint8_t key_mask );
uint8_t get_key_long_PIND_high( uint8_t key_mask );


volatile uint8_t key_state_PIND_high;        // debounced and non-inverted key state: bit = 1: key pressed, liest den Zustand eines Ports ein gemäß der Maske
volatile uint8_t key_press_PIND_high;        // key press detect active high
volatile uint8_t key_rpt_PIND_high;


//Timer1 16-bit Compare Match B Interrupt Service Routine
ISR (TIMER1_COMPB_vect){
  static uint8_t u8Entprellcounter;
  u8Entprellcounter++;              
  if (u8Entprellcounter >= 3){            // alle 12ms Entprellfunktionen aufrufen
    // Entprellen des PIND active high
    static uint8_t ct0_PIND_high, ct1_PIND_high, rpt_PIND_high;
      uint8_t i_PIND_high;
       
      i_PIND_high = key_state_PIND_high ^ PIND;               // key changed?, not inverted!
      ct0_PIND_high = ~( ct0_PIND_high & i_PIND_high );              // reset or count ct0
      ct1_PIND_high = ct0_PIND_high ^ (ct1_PIND_high & i_PIND_high); // reset or count ct1
      i_PIND_high &= ct0_PIND_high & ct1_PIND_high;                    // count until roll over ?
      key_state_PIND_high ^= i_PIND_high;                             // then toggle debounced state
      key_press_PIND_high |= key_state_PIND_high & i_PIND_high;        // 0->1: key press detect
    
      if( (key_state_PIND_high & (1<<PD0)) == 0 )            // check repeat function
        rpt_PIND_high = REPEAT_START;                          // start delay
      if( --rpt_PIND_high == 0 ){
        rpt_PIND_high = REPEAT_NEXT;                            // repeat delay
        key_rpt_PIND_high |= key_state_PIND_high & (1<<PD0);
      }
      
    u8Entprellcounter = 0;                // Entprellcounter nullen
  }
  
  
  OCR1B = OCR1B+((F_CPU/8000000UL)*31999);                // Compare Match Register wieder vorladen, erzeugt ein Compare Match jede 4ms
  
}


/*Hauptprogramm Aufgaben:

Das Hauptprogramm
*/
int main(void)
{
  init_ports();                                  
  init_timer1();  

  // LED einschalten, dass man sieht, dass Spannung anliegt und µC läuft
  PORTLED &= ~( 1<<LED );  
  _delay_ms(300);
  PORTLED |= ( 1<<LED );

  while (1){
  
    if( get_key_short_PIND_high( 1<<PD0 )){
        PORTLED &= ~( 1<<LED );  
        _delay_ms(300);
        PORTLED |= ( 1<<LED );
    }
    
    if( get_key_long_PIND_high( 1<<PD0 )){
        PORTLED &= ~( 1<<LED );  
        _delay_ms(1000);
        PORTLED |= ( 1<<LED );
    }
  
  
  } // Ende main loop
} // Ende Hauptprogramm



// ----------------------------------------------------------------------------
// Funktionen
// ----------------------------------------------------------------------------

/*Funktion zum Initialisierein des µC*/
void init_ports(void) {

  // ===========================================================================================
  
  DDRB = 0x00;  

  DDRC = 0x00;              // Datenrichtungsregister zunächst alle Eingang
  
  DDRD = 0x00;              // Datenrichtungsregister zunächst alle Eingang 
  DDRD |= (1 << DDD3);    // LED als Ausgang
  PORTD |= (1 << PD1) | (1 << PD2) | (1 << PD3) | (1 << PD4);  // Pullups einschalten, LED ausschalten
  

  sei();                  // setzt globales Interrupt enable
  
  return;
}   

void init_timer1(void) {
  
  OCR1B = ((F_CPU/8000000UL)*31999);            // Berechnet den Compare Wert für 4ms bei max. 16Mhz Frequenz
  TIMSK |= (1 << OCIE1B);  
  TCNT1 = 0;                        
  TCCR1B |= (1 << CS10);    // kein Prescaler, Timer1 läuft maximal durch
  
  return;
}


// Funktion für Tastendruck-Erkennung Tasten gegen VCC
uint8_t get_key_press_PIND_high( uint8_t key_mask ) {
  cli();                                          // read and clear atomic !
  key_mask &= key_press_PIND_high;                     // read key(s)
  key_press_PIND_high ^= key_mask;                     // clear key(s)
  sei();
  return key_mask;
}

uint8_t get_key_state_PIND_high( uint8_t key_mask ){

  key_mask &= key_state_PIND_high;
  return key_mask;
}

uint8_t get_key_rpt_PIND_high( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt_PIND_high;                            // read key(s)
  key_rpt_PIND_high ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}

uint8_t get_key_short_PIND_high( uint8_t key_mask )
{
  cli();                                          // read key state and key press atomic !
  return get_key_press_PIND_high( ~key_state_PIND_high & key_mask );
}

uint8_t get_key_long_PIND_high( uint8_t key_mask )
{
  return get_key_press_PIND_high( get_key_rpt_PIND_high( key_mask ));
}

Taster hängt an PD0 mit 10k Pulldown gegen GND und 10k in Reihe zum 
Portpin, um den Strom zu begrenzen.
LED hängt an PD3

Der Taster ist also active high, weswegen ich auch diese Zeile die 
Negierung gelöscht habe:

i_PIND_high = key_state_PIND_high ^ PIND

Das Problem ist, dass ich den Taster betätige, gedrückt lasse und nach 
kurzer Zeit <1s die LED für 300ms leuchtet, ohne dass ich die Taste 
loslasse.
Die Funktionen sollen doch aber erst beim Loslassen entscheiden, ob eine 
Taste gedrückt ist oder nicht. So kann nämlich nicht zwischen lang und 
kurz unterschieden werden...

Kann jemand helfen?

[Karl H. (kbuchegg)]

> Der Taster ist also active high
aus welchem Grund?

Wenn dein taster aktiv high ist, dann ist das Einschalten der Pullup 
Widerstände kontraproduktiv. Vor allen Dingen dann, wenn du selber dann 
auch noch externe Pulldown Widerstände angebracht hast. Auf die Art 
kriegst du niemals einen sauberen low Pegel.
Auf einem AVR schliesst man die Taster active low an. Das ist das 
einfachste und macht am wenigsten Probleme. Gewöhn dich daran - das ist 
softwaremässig überhaupt kein Problem, bei den Abfragen dieses active 
low zu berücksichtigen und die Abfrage umzudrehen.

Empfehlung: schmeiss die Pulldown raus und hänge die Taster genau so an, 
wie 50 Millionen andere Programmierer weltweit auch. Und dann nimm den 
PeDa Code so wie er ist.

[Manfred Daret (Gast)]

Der Pullup an PD0 ist nicht aktiv, d.h. hier ist nur der externe 
Pulldown vorhanden und sollte ein sauberer low-Pegel sein.

Die Taste ist leider extern, d.h. nicht auf meiner Schaltung (zumindest 
in der späteren Anwendung) und schaltet 12V durch. Daher muss ich es so 
tun und auch so simulieren.

[Manfred Daret (Gast)]

Es scheint doch zu funktionieren, wie ich jetzt nochmal durch ändern der 
delay Zeiten herausgefunden habe.

Es ist aber nicht so, dass get_key_long erst beim Loslassen der Taste 
erkannt wird, sondern sobald die repeat Funktion einen repeat erkannt 
hat, auch wenn man noch auf der Taste steht.

[Peter D. (peda)]

Manfred Daret schrieb:
> Die Funktionen sollen doch aber erst beim Loslassen entscheiden, ob eine
> Taste gedrückt ist oder nicht.

Nö, sie entscheiden es zum frühest möglichen Zeitpunkt.