Universelle Tastenabfrage

Peter Dannegger schrieb:
> Sowas macht man am besten als Statemaschine.
> Für 3s Wartezeit muß der Timerinterrupt >12ms sein oder man nimmt ein
> uint16_t als Zähler.
> enum { OFF, ON, BLINK };
>
> int main()
> {
>   uint8_t state = OFF;
>   for(;;){
>     switch( state ){
>       case OFF:
>                   led_off();
>                   if( get_key_short( 1<<KEY1 ))
>                     state = ON;
>                   if( get_key_long( 1<<KEY1 ))
>                     state = ON;
>                   break;
>       case ON:
>                   led_on();
>                   if( get_key_short( 1<<KEY1 ))
>                     state = OFF;
>                   if( get_key_long( 1<<KEY1 ))
>                     state = BLINK;
>                   break;
>       case BLINK:
>                   led_blink();
>                   if( get_key_short( 1<<KEY1 ))
>                     state = OFF;
>                   if( get_key_long( 1<<KEY1 ))
>                     state = OFF;
>                   break;
>     }
>   }
> }

Hallo,
doofe Frage, aber bist du sicher dass das so funktioniert?
Ich habe das meiner Meinung nach genauso, allerdings passiert auf 
Tastendruck nichts. Außerhalb der SM funktioniert es tadellos.
Jemand eine Idee?
Danke!

1

#ifndef F_CPU

2

#define F_CPU 1000000UL

3

#endif

4

5

#define KEY_DDR         DDRA

6

#define KEY_PORT        PORTA

7

#define KEY_PIN         PINA

8

#define KEY0            0

9

#define KEY1            1

10

#define KEY2            2

11

#define KEY3      3

12

#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2 | 1<<KEY3)

13

14

#define REPEAT_MASK     (1<<KEY1)       // repeat: key0, key2

15

#define REPEAT_START    50                        // after 500ms

16

#define REPEAT_NEXT     20                        // every 200ms

17

18

#define LED_DDR         DDRA

19

#define LED_PORT        PORTA

20

#define LEDBLUE         4

21

#define LEDYELLOW       5

22

#define LEDRED          6

23

#define LEDGREEN    7

24

25

#include <stdint.h>

26

#include <avr/io.h>

27

#include <stdio.h>

28

#include <util/delay.h>                // for _delay_ms()

29

#include <avr/interrupt.h>

30

#include "lcd.h"

31

32

volatile uint8_t key_state;                                // debounced and inverted key state:

33

                          // bit = 1: key pressed

34

volatile uint8_t key_press;                                // key press detect

35

36

volatile uint8_t key_rpt;                                  // key long press and repeat

37

38

39

ISR( TIMER0_OVF_vect )                            // every 10ms

40

{

41

  static uint8_t ct0, ct1, rpt;

42

  uint8_t i;

43

44

  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms

45

46

  i = key_state ^ ~KEY_PIN;                       // key changed ?

47

  ct0 = ~( ct0 & i );                             // reset or count ct0

48

  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1

49

  i &= ct0 & ct1;                                 // count until roll over ?

50

  key_state ^= i;                                 // then toggle debounced state

51

  key_press |= key_state & i;                     // 0->1: key press detect

52

53

  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function

54

  rpt = REPEAT_START;                          // start delay

55

  if( --rpt == 0 ){

56

    rpt = REPEAT_NEXT;                            // repeat delay

57

    key_rpt |= key_state & REPEAT_MASK;

58

  }

59

}

60

61

///////////////////////////////////////////////////////////////////

62

//

63

// check if a key has been pressed. Each pressed key is reported

64

// only once

65

//

66

uint8_t get_key_press( uint8_t key_mask )

67

{

68

  cli();                                          // read and clear atomic !

69

  key_mask &= key_press;                          // read key(s)

70

  key_press ^= key_mask;                          // clear key(s)

71

  sei();

72

  return key_mask;

73

}

74

75

///////////////////////////////////////////////////////////////////

76

//

77

// check if a key has been pressed long enough such that the

78

// key repeat functionality kicks in. After a small setup delay

79

// the key is reported being pressed in subsequent calls

80

// to this function. This simulates the user repeatedly

81

// pressing and releasing the key.

82

//

83

uint8_t get_key_rpt( uint8_t key_mask )

84

{

85

  cli();                                          // read and clear atomic !

86

  key_mask &= key_rpt;                            // read key(s)

87

  key_rpt ^= key_mask;                            // clear key(s)

88

  sei();

89

  return key_mask;

90

}

91

92

///////////////////////////////////////////////////////////////////

93

//

94

// check if a key is pressed right now

95

//

96

uint8_t get_key_state( uint8_t key_mask )

97

98

{

99

  key_mask &= key_state;

100

  return key_mask;

101

}

102

103

///////////////////////////////////////////////////////////////////

104

//

105

uint8_t get_key_short( uint8_t key_mask )

106

{

107

  cli();                                          // read key state and key press atomic !

108

  return get_key_press( ~key_state & key_mask );

109

}

110

111

///////////////////////////////////////////////////////////////////

112

//

113

uint8_t get_key_long( uint8_t key_mask )

114

{

115

  return get_key_press( get_key_rpt( key_mask ));

116

}

117

118

119

120

int main(void)

121

{  

122

  int displaystate=0;

123

  typedef enum

124

  {

125

    READY=0,

126

    STARTMEASUREMENT

127

  } current_state;

128

129

  current_state state = READY;

130

131

  LED_DDR = 0xFF;

132

133

  // Configure debouncing routines

134

  KEY_DDR &= ~ALL_KEYS;                // configure key port for input

135

  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

136

137

  TCCR0B = (1<<CS02)|(1<<CS00);         // divide by 1024

138

  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms

139

  TIMSK0 |= 1<<TOIE0;                   // enable timer interrupt

140

141

  sei();

142

143

  lcd_init(LCD_DISP_ON);        // Initialize LCD

144

145

  while(1){

146

    switch (state)

147

    {

148

      case READY:

149

          if(displaystate==0){

150

            lcd_clrscr();

151

            lcd_puts("Bereit");

152

            displaystate=1;

153

          }

154

          LED_PORT = (1<<LEDGREEN);

155

          if( get_key_short( 1<<KEY3 )){

156

            displaystate=0;

157

            state=STARTMEASUREMENT;

158

          }

159

          if( get_key_long( 1<<KEY3 )){  

160

            displaystate=0;

161

            state=STARTMEASUREMENT;

162

          }

163

          break;

164

165

      case STARTMEASUREMENT:

166

          if(displaystate==0){

167

            lcd_clrscr();

168

            lcd_puts("State1");

169

            displaystate=1;

170

          }

171

          LED_PORT = (1<<LEDYELLOW);

172

          if( get_key_short( 1<<KEY2 )){

173

            displaystate=0;

174

            state=READY;

175

          }

176

          if( get_key_long( 1<<KEY2 )){

177

            displaystate=0;

178

            state=READY;

179

          }

180

          break;

181

        }

182

  }

183

}

Hallo,
ich bin noch mal alles Schritt für Schritt durchgegangen und habe es mit 
deinem Code verglichen. Da ist mir dann letztendlich aufgefallen, dass 
ich die Pullups in einem Schritt wieder ausgeschaltet hatte.

Danke für deine ganzen Mühen und die viele Hilfestellung!

Hallo,

bei mir reagieren die Taster nicht ;/
Musste ein paar Anpassungen der Timer für den Attiny841 vornehmen. Die 
ISR wird alle 10ms aufgerufen, dass soweit schon richtig.

Die Leds hab ich direk an PINA 0 - 2 angeschlossen und auf der anderen 
Seite mit einem 470Ohm Widerstand nach GND verbunden.

Die Taster sind direkt mit PINB 0 - 2 verbunden und auf der anderen 
Seite mit GND verbunden.

1

#include <stdint.h>

2

#include <avr/io.h>

3

#include <avr/interrupt.h>

4

5

#define F_CPU 8E6

6

7

#define KEY_DDR         DDRB

8

#define KEY_PORT        PORTB

9

#define KEY_PIN         PINB

10

#define KEY0            0

11

#define KEY1            1

12

#define KEY2            2

13

#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

14

15

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2

16

#define REPEAT_START    50                        // after 500ms

17

#define REPEAT_NEXT     20                        // every 200ms

18

19

#define LED_DDR         DDRA

20

#define LED_PORT        PORTA

21

#define LED0            0

22

#define LED1            1

23

#define LED2            2

24

25

volatile uint8_t key_state;                                // debounced and inverted key state:

26

// bit = 1: key pressed

27

volatile uint8_t key_press;                                // key press detect

28

29

volatile uint8_t key_rpt;                                  // key long press and repeat

30

31

32

ISR( TIMER0_OVF_vect )                         // every 10ms

33

{

34

  static uint8_t ct0, ct1, rpt;

35

  uint8_t i;

36

37

  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);

38

39

  i = key_state ^ ~KEY_PIN;                       // key changed ?

40

  ct0 = ~( ct0 & i );                             // reset or count ct0

41

  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1

42

  i &= ct0 & ct1;                                 // count until roll over ?

43

  key_state ^= i;                                 // then toggle debounced state

44

  key_press |= key_state & i;                     // 0->1: key press detect

45

46

  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function

47

  rpt = REPEAT_START;                          // start delay

48

  if( --rpt == 0 ){

49

    rpt = REPEAT_NEXT;                            // repeat delay

50

    key_rpt |= key_state & REPEAT_MASK;

51

  }

52

53

  static uint8_t ct;

54

  if(++ct == 50) { LED_PORT ^= 1<<LED2; ct= 0;}

55

}

56

57

58

uint8_t get_key_press( uint8_t key_mask )

59

{

60

  cli();                                          // read and clear atomic !

61

  key_mask &= key_press;                          // read key(s)

62

  key_press ^= key_mask;                          // clear key(s)

63

  sei();

64

  return key_mask;

65

}

66

67

uint8_t get_key_rpt( uint8_t key_mask )

68

{

69

  cli();                                          // read and clear atomic !

70

  key_mask &= key_rpt;                            // read key(s)

71

  key_rpt ^= key_mask;                            // clear key(s)

72

  sei();

73

  return key_mask;

74

}

75

76

uint8_t get_key_state( uint8_t key_mask )

77

{

78

  key_mask &= key_state;

79

  return key_mask;

80

}

81

82

uint8_t get_key_short( uint8_t key_mask )

83

{

84

  cli();                                          // read key state and key press atomic !

85

  return get_key_press( ~key_state & key_mask );

86

}

87

88

uint8_t get_key_long( uint8_t key_mask )

89

{

90

  return get_key_press( get_key_rpt( key_mask ));

91

}

92

93

int main( void )

94

{

95

  LED_DDR |= (1<<LED0) | (1<<LED1) | (1<<LED2);

96

97

  // Configure debouncing routines

98

  KEY_DDR &= ~ALL_KEYS;                // configure key port for input

99

  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

100

101

  TCCR0B = (1<<CS02)|(1<<CS00);         // divide by 1024

102

  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms

103

  TIMSK0 |= 1<<TOIE0;                   // enable timer interrupt

104

105

  sei();

106

107

  while(1){

108

    if(get_key_short( 1<<KEY0 ))  // Led2 togglen

109

    LED_PORT ^= 1<<LED0;

110

111

    if( get_key_short( 1<<KEY1 ))  // Led1 togglen

112

    LED_PORT ^= 1<<LED1;

113

114

    if( get_key_short( 1<<KEY2 ))  // Leds loeschen

115

    LED_PORT &= ~((1<<LED0) | (1<<LED1));

116

  }

117

}

Die key_press Variante macht auch nichts, ausser die Leds direkt auf 
HIGH zu setzen.

Das mit der neuen Ansteuerung mit PUEx hatte ich bislang nicht gewusst.

Laut dem Datenblatt werden die Pullups wie folgt gesetzt.

PUEx |= (1<<PUEx1) | (1<<PUEx0);
die einzelnen Bits PUEx0 sind im Atmel Studio nicht per defines gesetzt. 
Spielt aber keine Rolle. Da ich die auch mit 0, 1  etc machen kann. 
Jedoch geht es so wie ich mir gedacht habe nicht.

1

  KEY_DDR &= ~ALL_KEYS;                // configure key port for input

2

  PUEB |= ALL_KEYS;

3

  //KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

F_CPU ist 8MHz

Der Takt ist hier NICHT das Problem! Das geht. Ob nun "8E6" oder 
"8000000UL" spielt keine Rolle.

Quarz ist keiner im Einsatz. Ich arbeite mit der internen Oscillator. 
Der läuft mit 8MHz

Das Atomisieren per cli(); sei(); finde ich ein wenig heftig. In meiner 
App läuft parallel ein anderer Interrupt, der alle 256 CPU cycles für 
ein paar Takte  zuschlägt (soft PWM). Der würde regelmäßig und oft 
gekillt.

Es geht ja nur darum, den Tasten - Debouncer für die Dauer der 
Tastenstatus Abfragen lahm zu legen. Andere Interrupts, die die Tastatur 
- Variablen nicht verändern, dürfen ja schadlos laufen ... od'r?

Ich lösche / setze daher selektiv nur das Timer - Interrupt Enable Bit 
des 10ms Timers. Sollte - was sehr unwahrscheinlich, aber immerhin 
möglich ist - genau während dieser Sperre ein Timer Overflow eintreten, 
gibt's in der Tastatur (und nur dort) einen Glitch von 10ms ... das ist 
meiner Meinung nach vertretbar.

@Uwe S

Servus,

wieder mal nachgelesen ... hast recht ... für den Fall, dass der 10ms 
key-Timer während der Atomexplosion überläuft (und das entsprechende 
Timer Interrupt Flag 0 ist) wird der Interrupt gespeichert und nach dem 
erneuten Setzen des Flags ausgeführt (in meinem Fall TIFR2.TOV2)

Liebe Grüsse aus +/- Wien

Moin,

ich nutze die Entprellroutine auf einem STM32F1 und habe bei einem 
Taster festgestellt, dass er häufiger nicht als gedrückt erkannt wurde.
Die Funktion im IRQ wird alle 10ms aufgerufen und es gab keine atomic 
Blöcke in den Tastenfunktionen.
Nun dachte ich mir, alle IRQs sperren ist etwas zu viel des Guten, es 
geht ja nur um das Auslesen der Tastenpins.
Spricht etwas gegen folgenden Ansatz?
In der debounce.c

1

static volatile uint8_t IRQdoNotReadFlag;

2

3

uint16_t get_button_press(uint16_t button_mask) {

4

  IRQdoNotReadFlag = 1;

5

  button_mask &= button_press;

6

  button_press ^= button_mask;

7

  IRQdoNotReadFlag = 0;

8

  return button_mask;

9

}

in der Funktion die dann im IRQ aufgerufen wird:

1

void call_button_in_IRQ(void)                  // Call this in SysTick-Handler

2

{                                              // Should be called every 10ms

3

  static uint16_t ct0, ct1;

4

  #ifdef USE_KEY_REPEAT

5

    static uint16_t rpt;

6

  #endif

7

  uint16_t i;

8

  uint16_t BUTTON_MASK_NOW = BUTTON_PORT;    // get Stade of the InputDataRegister for the used Port

9

  if (!IRQdoNotReadFlag) {

10

11

    i = button_state ^ BUTTON_MASK_NOW;        // key changed ?

12

    ct0 = ~(ct0 & i);                          // reset or count ct0

13

    ct1 = ct0 ^ (ct1 & i);                     // reset or count ct1

14

    i &= ct0 & ct1;                            // count until roll over ?

15

    button_state ^= i;                         // then toggle debounced state

16

    button_press |= button_state & i;          // 0->1: key press detect

17

18

  #ifdef USE_KEY_REPEAT

19

    if ((button_state & REPEAT_MASK) == 0)     // check repeat function

20

      rpt = REPEAT_START;                    // start delay

21

    if (--rpt == 0) {

22

      rpt = REPEAT_NEXT;

23

      button_rpt |= button_state & REPEAT_MASK;

24

    }

25

  #endif

26

  }

27

}

Das scheint schon deutlich besser zu funktionieren, ich habe aber den 
Eindruck, dass gelegentlich "kurze" Tastendrücke doch noch unerkannt 
bleiben. Bin mir aber nicht ganz sicher, ob es nicht evtl. die 
Entprellung ist. Eigentlich müsste aber ein gedrückter Taster deutlich 
länger dauern, als die Entprellzeit.

Hallo Uwe,

danke für die Antwort. Interessanter Gedanke, das ergibt durchaus Sinn.
Wie macht man das denn bei den STM32? Bei mir sorgt der SysTick für die 
10ms Zeitbasis, aber das wird ja auch noch für andere Dinge benutzt und 
daher möchte ich das nicht aus dem Takt bringen.
Je häufiger ich also Tastenabfragefunktionen benutze, desto häufiger 
würde der SysTick IRQ kurzzeitig gesperrt werden...

Wenn ich über

1

SysTick->CTRL  &= ~SysTick_CTRL_TICKINT_Msk; /* Disable SysTick IRQ */

den SysTick IRQ in den Tastenabfragefunktionen ausschalte und kurz 
danach wieder anschalte, wird er vermutlich nicht nachgeholt.

http://www.compuphase.com/electronics/debouncing.htm

Falls ihr immer noch Schwierigkeiten oder ein Brett vorm Kopf habt, lest 
euch die Erklärung im Link auch mal durch. Etwas kleinschrittiger.
Ich habe etwas gebraucht (also nen guten halben Bleistift) an Hand des 
obigen Codes das Konzept nachzugehen. Man hat, glaub ich, einfach zuerst 
Probleme sich klar zu machen, was Peter wann als logisch '1' und '0' 
speichert (die internen Zustände und aktuellen Ports) und dass das Ding 
halt rückwärts zählt.

Wenn es nur um das Entprellen geht, reicht es, wenn der Eingang in 
definierten Zeitintervallen (Timer-Int.) abgefragt wird, die größer sind 
als die max. Prellzeit.

Beispiel:
Der Taster wurde gedrückt und prellt noch während der 1. Abfrage.

Möglichkeit 1:
Er wird während des Prellens zufällig als "nicht gedrückt" erfasst. 
Nicht weiter schlimm: Er war vorher nicht gedrückt und wird nun eben für 
eine Intervall-Länge weiterhin als "nicht gedrückt" angesehen. Danach 
hat er ab der 2. Abfrage ausgeprellt und wird fortan statisch als 
"gedrückt" erfasst, solange er gedrückt bleibt.

Möglichkeit 2:
Er wird schon während des Prellens zufällig als "gedrückt" erfasst. 
Prima! Das war ja auch die Absicht beim Drücken. Bei den folgenden 
Abfragen hat er ausgeprellt und wird weiterhin statisch als "gedrückt" 
ausgewertet.

Mehr Aufwand zum reinen Entprellen braucht's nicht.

Alles darüber Hinausgehende dient nicht mehr dem Entprellen des Tasters, 
sondern der prophylaktischen Störunterdrückung von extern eingestreuten 
Spikes oder Bursts auf die mitunter langen Taster-Zuleitungen. Wo diese 
Störquellen ausgeschlossen werden können, reicht die Timer-Entprellung.

Spart wieviele FLASH-/RAM-Bytes?
Ganz abgesehen von der Implementierungs-/Fehlersuch-/Umbau(weils doch 
mehr Funktion braucht)-Zeit.
Es gibt was, das tut was es soll, wozu also neues erfinden.

@Bastler

Es ging mir nur um die simple Betrachtung des reinen Entprellens, das 
bzgl. der Komplexität meist 'überkandidelt' interpretiert und "gelöst" 
wird.

Dazu braucht es nicht eine einzige zusätzliche Codezeile. Die 
Eingangsabfrage muss ohnehin gemacht werden. Indem man diese in einen 
zeitlich passenden Timerinterrupt verfrachtet, ist das reine 
"Entprellungsproblem" gelöst, wie ich im vorigen Beitrag gezeigt habe.

Dort wo diese reine Entprell-Funktionalität ausreicht, braucht man keine 
All-inclusive-Routine.

Hallo Simpel,

im rein mathematischen Sinn, hast Du leider nichts gezeigt.

Anforderung, ich habe 8 Tastereingänge und möchte verschiedene Events 
von der Entprellroutine erhalten.

1) Wurde eine Taste gedrückt ?
2) Wurde eine Taste losgelassen ?
3) Ist eine Taste immer noch gedrückt (repeat pressed) ?
4) Wurde eine Taste nur kurz gedrückt ?

Bitte schreibe, als Beweis, das Vorgegebene als Code deine bevorzugten 
Programmiersprache nieder.

Hallo,
ich habe die Entprellung bei mir mit einem PIC implementiert, und sie 
funktioniert auch einwandfrei.

Jetzt habe ich aber ein Problem weil ich einen zweiten Timer habe der 
alle 148 us aufgerufen wird.
Mein Timer für den Entpreller ist auf 10ms gestellt.

der zweite Timer hat eine höhere Priorität, aber selbst ohne die bringt 
er die Routine anscheinend so durcheinander das Tasten als gedrückt 
erkannt werden obwohl diese nicht gedrückt werden. Oder erst nach 
mehrmaligem schnellen drücken erkannt werden.

Kann das an dem schnellen Timer liegen oder habe ich doch irgendwo in 
meinem Code mist gebaut? Sobald ich den Timer deaktiviere oder dessen 
Interrupt funktioniert alles.

Ich kann meine Frage selber beantworten...

Zitat datasheet:
If both low-priority and high-priority interrupts are
enabled, the Stack registers cannot be used reliably to
return from low-priority interrupts. If a high-priority
interrupt occurs while servicing a low-priority interrupt,
the Stack register values stored by the low-priority
interrupt will be overwritten. In these cases, users must
save the key registers in software during a low-priority
interrupt.

Normalerweise erledigt das ja der Compiler.
Natürlich unter der Voraussetzung das man richtig programmiert.
Auszug aus dem C Compiler Handbuch:
A high-priority interrupt uses the shadow registers to save and restore 
the minimal context, while a low-priority interrupt uses the software 
stack to save and restore the minimal context

1

#pragma code

2

#pragma interrupt high_prior_InterruptHandler

3

4

void high_prior_InterruptHandler(void)

5

{}

6

7

#pragma code

8

#pragma interrupt low_prior_InterruptHandler

9

void low_prior_InterruptHandler(void)

10

{}

Keine Ahnung ob das aus einem Beispiel kopiert wurde oder wo ich das her 
hatte, das Projekt liegt schon etwas länger in der Ecke.
Wenn aber für beide Interrupts das gleiche Register zum speichern 
verwendet wird, tritt denke ich genau das ein was oben beschrieben 
wurde.

1

#pragma code

2

#pragma interruptlow low_prior_InterruptHandler

3

void low_prior_InterruptHandler(void)

4

{}

Das ist also korrekt. Und jetzt funktioniert es auch :)

Hallo Peter!

Deine Entprell-Routine nutze ich schon seit ein paar Jahren - vielen 
Dank dafür!

Nun wollte ich die get_key_long() Funktion anwenden (zur Einstellung 
eines Zahlenwertes: kurzer Druck = +1, langer Druck = +10).

Ergebnis: Ein langer Tastendruck wird zuverlässig erkannt. Bei einem 
kurzen gibt es leider nur eine Erfolgsquote von ca. 90%, d.h. etwa jeder 
10te wird falsch als langer Tastendruck erkannt.
Etwas verwirrt habe ich einen Attiny13A nur mit der Entprellroutine 
gefüttert, ein Knopf, zwei LEDs, 9,6MHz/8, verschiedene Werte für 
REPEAT_START und  REPEAT_NEXT, aber dasselbe Problem.
Hat jemand schon einmal Åhnliches beobachtet?


Außerdem ist mir folgendes aufgefallen:
Ich hatte den Sinn von REPEAT_NEXT so verstanden, dass ein weiterer 
langer Druck gezählt wird, wenn der Knopf nach Ablauf dieses 
Zeitintervalls immer noch gedrückt ist.

Nun wird in der get_key_long() aber hier:

1

return get_key_press( get_key_rpt( key_mask ));

key_press durch den Aufruf von get_key_press() gelöscht, und jeder 
folgende Aufruf von get_key_long() liefert 0, auch wenn in key_rpt das 
entsprechende Bit gesetzt ist.
Mit

1

return (key_press & get_key_rpt( key_mask ));

wird es etwas besser, aber dann gibt's nach jedem langen Tastendruck 
einen kurzen "gratis", was wohl auch nicht der "Spezifikation" 
entspricht...
Mir fällt aber nix ein, wie man dies ohne Einführung einer weiteren 
Variable lösen könnte.

Folgender Code funktioniert bei mir einwandfrei:

1

static uint8_t lcd_update = 0;

2

static char buffer[20];

3

static uint32_t counter = 0;

4

5

      // decrement

6

      if (get_key_press(1<<KEY_DEC))

7

      {

8

        if (counter > 0)

9

        {

10

          counter--;

11

          lcd_update = 1;

12

        }

13

      }

14

      if (get_key_rpt(1<<KEY_DEC))

15

      {

16

        if (counter >= 10)

17

        {

18

          counter -= 10;

19

        }

20

        else

21

        {

22

          counter = 0;

23

        }

24

25

        lcd_update = 1;

26

      }

27

28

29

      if (lcd_update)

30

      {

31

        lcd_update = 0;

32

        lcd_setcursor(0,1);

33

        sprintf(buffer, "%16" PRIu32 "", counter);

34

        lcd_string(buffer);

35

      }

lg
Chris

Hallo Chris,

OK, auch da wird natürlich ein langer Druck zusätzlich als kurzer 
gezählt - allerdings gleich am Anfang und nicht erst beim Loslassen.
Das dürfte für den User besser einzuschätzen und komfortabler sein.

Hast Du schon einmal das Problem mit "falsch-langen" gehabt (also einem 
kurzen Druck, der als langer erkannt wurde?)

Mit welchem Takt arbeitest Du? Wieviele Interrupts generierst Du?

In meiner "richtigen" Anwendung habe ich F_CPU = 1MHz. Ich brauche einen 
Millisekunden-Takt, den ich mit TIM0_COMPA generiere.
Bei jedem 10. wird dann per

1

 if (!(msec % 10))

2

  {

3

  debounce();

4

...

die Abfrage der Taster vorgenommen.
Der Tiny13A zum Testen taktet geringfügig höher (9,6/8MHz).

Hi,

genau, der erste Tastendruck erhöht um 1 (bzw. erniedrigt in meinem 
Beispiel). Hält man weiter gedrückt, wird in 10er Schritten gezählt. 
Beim Loslassen passiert nichts.

Ich führe die Tastenentprellung im Timerinterrupt alle 10 ms durch.
Wenn ich auch einen ms-Takt brauche, stelle ich den Interrupt auf 1ms 
und zähle im Interrupt eine Variable bis 10 hoch. Die Entprellfunktion 
rufe ich direkt im Interrupt (als inline Funktion) auf.

AVR-Bastler schrieb im Beitrag #4472189:
> if (!(msec % 10))
>   {
>   debounce();
> ...


Da fällt mir gerade auf:
Wenn dieser Code bei dir in der Hauptschleife steht, kann er innerhalb 
einer Millisekunde öfter aufgerufen werden, wenn deine Schleifenlaufzeit 
kleiner als 1 ms ist. Weil die geprüfte Bedingung ja die ganze Zeit 
erfüllt ist, bis msec erhöht wird.
Das würde das falsch-erkennen der langen/kurzen Tastendrücke erklären.
Mach vielleicht besser einen Zähler, der bis 10 zählt und wieder auf 0 
gesetzt wird. Dann wird wirklich nur jedes 10. mal die Entprellung 
durchgeführt.

chris schrieb:
> Da fällt mir gerade auf:
> Wenn dieser Code bei dir in der Hauptschleife steht, kann er innerhalb
> einer Millisekunde öfter aufgerufen werden,

Das ist ein valider Punkt. - Danke!
Ich dachte schon, das war's. Leider nein.

Aber ich habe nun mit den Zeiten noch etwas gespielt.
Wenn ich die debounce() alle 50ms aufrufe, funktioniert es. Dafür fallen 
dann sehr schnelle Tastendrücke hinten runter.

Also kann ich mir aussuchen, ob ich am langen oder am kurzen (Zeit-) 
Ende Fehler habe.
Ich denke, der Taster ist einfach schrottig.

AVR-Bastler schrieb im Beitrag #4473359:
> Das ist ein valider Punkt. - Danke!
> Ich dachte schon, das war's. Leider nein.

Wie sieht denn dein aktueller (vollständiger) Code aus?

Hallo Peter,

Peter D. schrieb:
> Dann ist die Zeit für lang zu lurz.

Ich habe die REPEAT_START schon auf 255.

Aber danke für die get_key_long_r() und get_key_rpt_l(). Ich werde die 
morgen mal simulieren.

Sorry - hab gerade "Land unter", da bin ich noch nicht wieder dazu 
gekommen.

Deine Rechnung ist natürlich richtig, Peter.
Deine Annahme, ich würde bei der Fehlersuche wahllos alle Parameter 
gleichzeitig ändern, natürlich nicht.

Aber auch 255*10ms = 2,55s ist für einen Anwender zu lang. Trotzdem habe 
ich es damit mal versucht, einfach um herauszufinden, ob dieser 
Parameter das Problem löst. Hat er nicht.