www.mikrocontroller.net

Forum: Projekte & Code Universelle Tastenabfrage


Autor: peter dannegger (Gast)
Datum:
Angehängte Dateien:

Bewertung
1 lesenswert
nicht lesenswert
Unter "Tasten entprellen - Bulletproof" ist eine zuverlässige
Entprellung und gedrückt Erkennung für 1 .. 8 Tasten beschrieben.

Aber oftmals will man Tasten sparen, indem man unterschiedliche
Aktionen bei kurzem oder langem Drücken ausführt.

Außerdem ist eine Wiederholfunktion z.B. bei Eingabe von Werten
wünschenswert.

All das kann man mit wenigen weiteren Kodezeilen erreichen.

Im Interrupthandler wird eine Variable runtergezählt, sobald eine für
die Wiederholerkennung vorgesehene Taste gedrückt wurde. Nach der
Startzeit bzw. Wiederholzeit wird dann das Tastenbit in der Variable
key_rpt gesetzt. Die Startzeit und Wiederholzeit können unterschiedlich
gewählt werden.
Um nun einen Stellwert hochzuzählen, wird einfach die Funktion
get_key_rpt() aufgerufen, die dann das Tastenbit in key_rpt abfragt und
zurücksetzt. Damit zwischen Abfragen und Zurücksetzen kein
Timerinterrupt reinhaut, muß beides unter Interruptsperre erfolgen.

Die nächste neue Funktion ist get_key_short() für die Erkennung des
kurz Drückens. Das kann aber erst nach dem Loslassen erkannt werden.
Dazu wird der key_state ausgewertet, d.h. erst wenn dort das Tastenbit
wieder 0 ist, wird get_key_press() ein Wert übergeben, und kann
ausgeführt werden. Damit dazwischen kein Timerinterrupt erfolgt, muß
vor der Abfrage von key_state der Interrupt gesperrt werden,
get_key_press() enabled dann wieder die Interrupts.
Wird nur get_key_short() aufgerufen, d.h. nicht mit get_key_long() im
Wechsel, dann liefert es auch einen Wert zurück nach langem Drücken.

get_key_long() wiederum liefert erst dann einen Wert, wenn beide
Funktionen get_key_rpt() und get_key_press() das Tastenbit gesetzt
haben.

Anbei ein Programmbeispiel für alle 4 Funktionen.


Peter

Autor: Fabian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

Klasse! Ich benutze deine "normale" Entprellroutine schon ne
Weile...funktioniert einwandfrei. Die neue Funktionalität ist das
einzige was ich bisher vermisst hab...
Nur nochmal ne Frage dazu:

die Zeile
TCNT0 = (u8)(s16)-(XTAL / 1024 * 10e-3 + 0.5);  // preload for 10ms
tut was genau?
Wäre klasse wenn du die etwas "aufschlüsseln" könntest.

Gruß
Fabian

Autor: peter dannegger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Fabian

"die Zeile
TCNT0 = (u8)(s16)-(XTAL / 1024 * 10e-3 + 0.5);  // preload for 10ms
tut was genau?"


Nun T0 hat ja kein Compareregister.
Um ihn zu verkürzen, muß man ihn in jedem Interrupt neu laden.
Ein Laden mit -9 bedeutet, daß der nächste Interrupt nach 9
Zählschritten erfolgt.

XTAL ist die Quarzfrequenz (z.B. 1MHz)
1024 ist der Vorteiler
10e-3 = 10ms
+0.5 rundet
(s16) convertiert den float-Wert nach integer.
(u8) schneidet das High-Byte ab, da TCNT0 ja nur 8-bittig ist.


Peter

Autor: Fabian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Alles klar...der erste Overflow passiert aber ganz normal nach 255ms
oder? also 1Mhz/1024 * 255 ... erst beim ersten overflow stellste ja
auf 10ms "um".

Richtig verstanden?

Gruß
Fabian

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,

möcht nen FIFO anlegen, um Tastendrücke auch dann nicht zu verlieren,
wenn die Anwendung mit einer anderen Funktion bissel länger beschäftigt
ist.

Im Timer0-INT könnte ich dazu doch auch gleich die Bodys der
get_key_xx()-Funktionen unterbringen, die so erweitert werden, daß sie
ins FIFO schreiben können und cli() / sei() weglassen oder ist das
schlechtes Design??? cli() / sei() dann natürlich in der Funktion, die
den FIFO ausliest wegen der FIFO-"head" u. "tail"-indizies, die
sonst fehlerhaft werden könnten.

THX Micha

Autor: peter dannegger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ne FIFO würde ich aber nur für die einfache Druckerkennung machen.

Bei lang/kurz/wiederholung braucht man unbedingt ein direktes Feedback,
es sei denn, man ist Morsefunker.


Peter

Autor: andre (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich blick nicht ganz durch den Code durch... Wie muss ich vorgehen,
wenn ich mit einem Taster bei kurzem und langem (ca. 1 sek) zwei
verschiedene Aktionen durchführen möchte?

andre

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@andre

"Wie muss ich vorgehen, wenn ich mit einem Taster bei kurzem und
langem (ca. 1 sek) zwei verschiedene Aktionen durchführen möchte?"

short = kurz
long = lang
//
      // release after short press: task 1
      // long press: task 2

    if( get_key_short( 1<<KEY1 ))
      LED_PORT ^= 1<<LED1;

    if( get_key_long( 1<<KEY1 ))
      LED_PORT ^= 1<<LED2;


Peter

Autor: andre (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich hab es so geändert:

#define REPEAT_MASK  (1<<KEY0)
#define REPEAT_START  100
#define REPEAT_NEXT  20


....

if( get_key_long( 1<<KEY0 ))
      value+=10;

 if( get_key_short( 1<<KEY0 ))
      value++;


Aber value wird immer 10 hochgezählt!

Autor: andre (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hab den Fehler gefunden... der Vorteiler vom Teiler war falsch
eingestellt...

Allerdings muss ich mehr als 2,5 Sekunden einstellen... da muss wohl
ein 16 bit int her.

Autor: Karl Kalchgruber (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,
ich hätte mal eine Frage zu deinem Code.
Wieso muß das lesen und zurücksetzen der Bits 'atomic' ausgeführt
werden? (z.B.: in Routine 'get_key_press')
Kommt das von der AVR-Architektur? (kenne diese nicht!)

/Koarl

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
atomic meint, nicht durch Interrupts unterbrechbar und das bewirkt man
mit der Klammerung durch cli() + sei().

Nur C-Instruktionen, die in eine einzige Assemblerinstruktion übersetzt
werden, sind von Haus aus atomic (nicht teilbar).


Peter

Autor: Karl Kalchgruber (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
mir ist schon klar was mit atomic gemeint. Was ich mich frage was würde
schief gehen wenn ich das 'atomic' weglasse.

z.B.: so

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

Meiner Meinung nach kann da falls ein Interrupt dazwischen kommt
nichts schief gehen. Da im Interrupt in der Variable 'key_press' nur
Bit gesetzt werden. (Oder ist auf dem AVR der 'AND' bzw. 'EXOR'
Befehl
nicht 'atomic')

/Koarl

Autor: peter dannegger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
key_press ^= key_mask;


Diese Instruktion besteht aus 3 Befehlen, ist also nicht atomar.

Wenn also genau zwischen lesen, exoren und zurückschreiben von
key_press der Timerinterrupt eine Taste erkennt, geht diese verloren.


Peter

Autor: Nils Hoffmann (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

ich habe heute den ganzen Tag damit verbracht (zu versuchen) den code
zu verstehen .... leider nur mit teilerfolgen ;) vielleicht kann mir
einer von euch weiter helfen.

Was mir am meisten Kopfschmerzen bereitet sind diese Shiftoperantionen
wie z.B.
#define REPEAT_MASK  (1<<KEY1^1<<KEY2)

auch dies hantieren mit den KEYs versteh ich nicht so ganz ... spricht
man damit einzelne Bits an oder sind das einfach Konstanten?
Falls es Konstanten sind warum macht man dann soetwas ?
if( get_key_long( 1<<KEY1 ))

könnte man da nicht einfach
if( get_key_long( 3 ))



Mit
#define KEY_PIN    PINB
werden doch die ganzen 8 Bit mit KEY_PIN verknüpft oder ? Dann müsste
es doch auch funktionieren wenn ich nur ein Bit des Ports mit KEY_PIN
verknüpfe oder nicht ? Folgendes ich habe einen Drehimpusgeber an
meinen Port0 (Atmel 8052)angeschlossen. Dieser hat 3 Adern ... 2 zur
Ermittlung der Drehrichtung und eine für den Drucktaster. Das Auswerten
des Drehimpulses habe ich mit Hilfe aus diesem Forum schon hinbekommen.
Vielen Dank nochmal !

*ich schweife schon wieder ab ;)*

Also Der Drehimpulsgeber ist folgendermaßen angeschlossen

P0^0 und P0^1 für die Drehrichtung
und
P0^2 für den Drucktaster

Deswegen möchte ich auch nur dieses Bit abfragen und mit der
Entprellroutine auswerten ... also habe ich
#define KEY_PIN    PINB
einfach durch
sbit KEY_PIN = P0^2;
ersetzt.


Die Tastenerkennung funktioniert jetzt auch, aber die Auswertung ob
lang oder kurz gedrückt worden ist leider nicht ....

Ich Programmiere in Keil und bin neu in der MC-Welt ... vielleicht kann
mir ja einer von euch etwas auf die Sprünge helfen?

Autor: Nils Hoffmann (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hm

der Beitrag war eigentlich noch nicht fertig ... bin versehentlich auf
"submit" gekommen ! Leider kann man seine eigenen Beiträge nicht
nachträglich Editieren ... jedenfalls hab ich nicht gefunden wo ...
Naja ich hoffe man versteht ihn !

Ich habe die KEIL version des Entprellcodes nochmal angehängt
vielleicht hab ich ja da schon einen Fehler drin....

MfG
Nils

Autor: peter dannegger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Nils,

der Code ist so geschrieben, daß immer ein ganzer Port entprellt wird.

Welche der Portpins einen nun aber wirklich interessieren, übergibt man
den Abfragefunktionen als Bitmaske, die der Compiler aus der Bitnummer
per (1<<Bitnummer) erzeugt.

In meinem Beispiel werden 3 Pins abgefragt (key0..key2).


Peter

Autor: Nils Hoffmann (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

Ich bin immer wieder überrascht wie schnell man in diesem Forum Antwort
bekommt ! Daumen hoch !! g


vielen Dank

MfG
Nils

Autor: duundich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wiederholung nach langem Tastendruck:
if( get_key_long( 1<<BUTTON ) || get_key_rpt( 1<<BUTTON ))

Fehlt noch die Erkennung von gleichzeitig gedrückten Tasten! Falls da
jemand ne Idee hat, ich krieg's nicht hin..

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@duundich

Meinst Du ne Shift-Taste ?
if( get_key_press( 1<<KEY1 ){
  if( key_state & (1<<SHIFT_KEY) ){
// do action Shift + KEY1
  }else{
// do action KEY1
  }
}


Peter

Autor: duundich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich fürchte nicht, da in diesem Fall der 'shift key' eine normale
Funktion hat: ich habe zwei Tasten, die jeweils bereits auf kurzen, und
langen||rpt Tastendruck geprüft werden, etwa so:
if( get_key_short( 1<<BUTTONA ))

programm -

if( get_key_short( 1<<BUTTONB ))

programm +

if( get_key_long( 1<<BUTTONA ) || get_key_rpt( 1<<BUTTONA ))

leiser

if( get_key_long( 1<<BUTTONB ) || get_key_rpt( 1<<BUTTONB )) 

lauter


Jetzt hätte ich gerne noch die Prüfung auf gleichzeitigen Tastendruck,
kurz oder lang (funktion: aus).
D.h., der Zustand müsste vor (oder/und nach) der Schwellzeit erkannt
werden, ohne, daß die anderen Prüfungen eingreifen. Das habe ich leider
nicht hinbekommen.

A        xxxxxxxxxxxxxx
B            xxxxxxxxxxxxxxxxx
T->                              |


Würde mich über einen Hinweis in die richtige Richtung sehr freuen!

Autor: noXe (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

also ich habe so eben versucht den Code vom peter dannegger an einem
mega8 auszuprobieren. Habe den PORTA durch PORTD ersetz und die XTAL
auf 16Mhz eingestellt....bekomme aber nichts sinnvolles raus. Die drei
LEDs läuchtet permanent und das wars.

Ne Idee was ich falsch gemacht haben könnte?

Autor: Pete (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Versuch es mal mit 1 Mhz.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@noXe

"Ne Idee was ich falsch gemacht haben könnte?"


Tja, was soll man dazu sagen ?

Wenn wenigstens die komplette Source als Anhang dabei wäre, dann könnte
man schonmal Softwarefehler suchen. Aber hellsehen kann ich leider
nicht.

Und so ins Blaue: "Versuch es mal mit 1 Mhz." bringt meistens
nichts.


Peter

Autor: André (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke an Peter für den Quelltext samt ausführlicher Kommentierung.
Hab erstmal ein bisschen Anlauf gebraucht um das Programm richtig zu 
deuten, da jeder einen etwas anderen Programmierstil hat.
Hab es auf meine Bedürfnisse angepasst und es funktioniert wunderbar.

Besten Dank nochmal dafür.

Autor: dagobert (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Bei dem von Peter realisierten Code ist ein konstanter Tastendruck 
(long) nicht wirklich möglich, oder sehe ich das falsch?
Bei längerem Drücken reagiert das System wie bei kurzem Tastendruck. 
Lediglich bei schnellem aufeinanderfolgenem Tastendruck kann eine 
Änderung (der Routine) festgestellt werden.
Ist dem so, oder habe ich etwas falsch gemacht?

Danke für Eure Hilfe

Autor: Jörg Bayer (senner05)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo zusammen,

ich hab nochmal eine Frage zum deaktivieren der Interrups.

Folgendes:
Ich hab den Code "missbraucht" um eine Tastenabfrage über RS232 zu 
realisieren. Das sieht im Prinzip so aus:
Jedesmal wenn eine Taste gedrückt wird (oder losgelassen) wird der 
keystate in einem byte gesendet.
Jedes Bit steht dabei für eine Taste.
Dieses Byte wird dann einfach für den "ursprünglichen" Tastenport 
verwendet!

Ich weiss, dass das garantiert auch eleganter gelöst werden kann aber 
mir gefällt es da ich dann auch ohne weiteres die zusätzlichen 
Tastenfunktionen nutzen kann (außerdem bin ich ein absoluter 
Programier-Anfänger so dass ich froh bin wenn es für etwas schon eine 
fertige Lösung gibt ;-)) - und es funktioniert soweit!

Das Problem das ich jetzt seh ist, wenn die Interrups deaktiviert sind 
kann ja auch kein neuer keystate empfangen werden - wie wahrscheinlich 
das ganze ist sein mal dahingestellt (der keystate wird zuerst bei einem 
receive-interrupt in einen Buffer geschrieben...) aber es ist nunmal 
Möglich!

Deshalb nochmal die Frage (ich habs oben nicht ganz verstanden):
Warum verlier ich den Tastendruck (nehmen wir mal an, dass die Tasten an 
einem Port sind)?
Und kann ich z.B. einfach alle Interrups außer dem 
UART-Receive-Interrupt deaktivieren? Ich mein das sind doch ganz andere 
Zeitdimensionen (empfangen -> in Buffer schreiben -> Buffer 
auswerten)...

Ich hoffe ihr könnt mir weiterhelfen

Gruß
Jörg

Autor: (geloescht) (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
(Dieser Beitrag wurde geloescht)

Autor: Markus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Ich versuche die Entprellroutine zu verwenden.
Leider hab ichs noch nicht ganz geschafft.

Ich hab einen ATTiny26 und versuche folgendes zu realisieren:

3 LEDs an PORTA 1,3,4
1 Taster an PINA 7

Das Programm soll wie folgt funktionieren:

- beim einschalten, alle LEDs aus.
- bei jedem kurzen tastendruck die nächste LED einschalten und bei der 
letzten bleiben bis....
- bei langem Tastendruck wieder auf 0 gesetzt wird.

Ich hoffe das war verständlich.

Dazu sind doch die Funktionen short und long oder?
mit der Funktion get_key_press funktioniert das raufzählen, aber wie 
realisiere ich den langen tastendruck mit dem rücksetzen?

Ich hoffe mir kann da wer helfen.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Markus wrote:

> Dazu sind doch die Funktionen short und long oder?

Genau.
Siehe Beispiel.
Nicht vergessen, die Taste in REPEAT_MASK einzutragen.


Peter

Autor: Markus (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Ich wollte eigentlich die Datei anhängen, hat aber scheinbar nicht 
geklappt.

Zum Problem:
Bei kurzem Tastendruck leuchtet die erste LED, danach geht sie gleich 
wieder aus.
Drücke ich mehrmals hintereinander funktioniert es auch. Sobald ich aber 
nicht mehr drücke gehen alle LEDs wieder aus.(sollte eigentlich erst bei 
key_press_long sein)

Also kann was an dieser Routine nicht stimmen.
Kann es sein, dass er da probleme hat, weil auch die LEDs am selben PORT 
liegen?

mfg markus

Autor: Markus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hab den Fehler gefunden.

Es lag daran, dass in dieser Routine die Taster aktive low sind. Meiner 
ist jedoch aktvie high.

Habe folgende Zeile geändert:
i = key_state ^ ~KEY_PIN; ->  i = key_state ^ KEY_PIN;

Das war hoffentlich richtig. Zumindest funktioniert es jetzt :)

Autor: Thomas Kühne (tommes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,
ich habe mich gerade mit deinem Code beschäftigt.
Ich glaube ich habe dabei nen Fehler gefunden:
und zwar einen allgemeinen Fehler bei der Behandlung von lange
gedrückten Tasten. Wenn ich deine Routine in der ISR richtig verstehe,
dann setzt du die rpt Zählvariable immer wieder auf den Ausgangswert
solange keine Taste gedrückt wird. Sobald eine Taste gedrückt ist,
geschieht dies nicht mehr und die rpt wird heruntergezählt. Jedoch
unterscheidet deine Routine dann nicht welche Taste gedrückt ist und wie
lange bereits. Kann nicht im Moment der Fall eintretten, dass (Annahme
REPEAT_START = 50) Taste 1 die ersten 40 Interrupts gedrückt ist und
nach Interrupt 30 auch noch Taste 2 hinzukommt. Nun wird im Code nach 50
Interrupts bei Taste 2 ein langes drücken festgestellt, obwohl sie nur
20 Interrupts gedrückt war. Ich hoffe das ist so weit verständlich.
Und sollte auch nur als Anregung dienen.

Gruß Thomas

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Thomas,

das ist absichtlich so.

In der Praxis ist es so, daß man nur eine Taste lange drückt, z.B. count 
up und losläßt, wenn der gewünschte Wert erreicht ist.
Würde man gleichzeitig count down drücken, würde der Wert immer +1,-1 
machen, was ja ziemlich sinnlos ist.


Damit man eine Shift-Taste definieren kann (z.B. count +1, oder +10), 
gibt es die Maske mit der nur die Repeat-Tasten definiert werden.

Zu entprellende Eingänge ohne Repeat können also gleichzeitig aktiv sein 
(z.B. Endlagenschalter).


Peter

Autor: Markus _neu (markush)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi Leutz,

ich versuche grad die Routine auf einem Mega32 mit 16MHz Takt zu 
benutzen. Ich hab das Original C-Beispiel aus der Artikelsammlung 
benutzt (http://www.mikrocontroller.net/articles/Entprellung). Zur 
Auswertung geb ich einen Text auf ein LCD aus:
    if( get_key_press( 1<<KEY0 )) {
      lcd_gotoxy(0,1);
      lcd_puts("T0");            
                    }
    if( get_key_press( 1<<KEY1 )) {
      lcd_gotoxy(0,1);
      lcd_puts("T1");            
                    }

    if( get_key_press( 1<<KEY2 )) {
      lcd_gotoxy(0,1);
      lcd_puts("T2");            
                    }


Soweit funktioniert das auch, nur zeigt bei mit der erste Taster T0 oft 
fälschlicherweise T1 an. Und zwar immer wenn vorher eine andere Taste 
gedrückt war. Ich hab schon die verschiedensten Sachen probiert, weiss 
mir aber mittlerweile nicht mehr weiter. Any hints?

Markus

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Markus _neu wrote:

> Soweit funktioniert das auch, nur zeigt bei mit der erste Taster T0 oft
> fälschlicherweise T1 an. Und zwar immer wenn vorher eine andere Taste
> gedrückt war. Ich hab schon die verschiedensten Sachen probiert, weiss
> mir aber mittlerweile nicht mehr weiter. Any hints?

Wackler, Kurzschluß, unterbrochene Pullups, ...


Schreib mal die LCD-Texte hintereinander, dann sieht mans besser.

So weißt Du ja nicht, ob ein Text von einem anderen überschrieben wurde 
und wie oft er geschrieben wird.


Peter

Autor: Markus _neu (markush)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger wrote:
>
>
> Schreib mal die LCD-Texte hintereinander, dann sieht mans besser.
>
> So weißt Du ja nicht, ob ein Text von einem anderen überschrieben wurde
> und wie oft er geschrieben wird.
>
>
> Peter

Ja, gute Idee. Werd ich heute abend gleich mal probieren.

Markus

Autor: Markus _neu (markush)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

danke für deine Tipps Peter. Das Problem waren nicht aktivierte interne 
Pullups !?!

Hab ich völlig übersehen. Durch das hinternander schreiben der Ausgabe 
konnte ich sehen dass da tatsächlich teilweise mehrere Tasterdrücke auf 
einmal registriert wurden.

Gruß - Markus

Autor: mgiaco (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was machen wenn man 10 Tasten braucht?
8 Stück funktionieren wunderbar.

danke
mathias

Autor: Falk Brunner (falk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ mgiaco (Gast)

>Was machen wenn man 10 Tasten braucht?

Da wird man wohl oder übel den Code anpassen müssen und auf zwei Ports 
zugreifen müssen. Oder gleich ne Matrix aufbauen, ist auch in der 
Codesamlung verfügbar.

MFG
Falk

Autor: ben (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hallo,
fang grad erst an und bräuchte nur ne ganz normale 
interrupt-tastenentprellung für einen taster.

würde mich über eine antwort sehr freuen.
ich hab nen AT90CAN64 grade dran...

gruß,

ben

Autor: Sebastian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich probier grade Peters C-Komfortroutine aus:
http://www.mikrocontroller.net/articles/Entprellun...

Mit WinAVR-20080430 funktioniert diese bei mir allerdings nur nach 
Einfügen einiger "volatile":
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

Anderer Punkt: Der letzte Code-Abschnitt in dem Beispiel soll wohl den 
Status der unteren drei LEDs erhalten und das Leuchten einer weiteren 
LED über die höheren fünf LEDs schieben:
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;
Dieser Teil geht bei mir im Simulator mit AVR-Studio 4.14 (auch 
anschaulich mit hapsim) sehr gut. In der Realität passiert beim Drücken 
von KEY2 allerdings nichts.
Ich habe LED_PORT PORTB und KEY_PORT PORTD, also die Standardschaltung 
aus dem ASM-Tutorial. Ins Blaue vermutet könnte das daran liegen, das 
mein Quarzoszillator mit an PortB hängt. Folgendes funktioniert nämlich 
(einfaches an/aus der vierten oder Blinken durch 
Wiederholungserkennung):
if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
    
  LED_PORT ^=0x08;

Viele Grüße & gn8 !
Sebastian

Autor: Sebastian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn 's da sonst keine Meinung zu gibt werde ich den Entprellung-Artikel 
mal entsprechend anpassen.
Grüße,
Sebastian

Autor: John Schmitz (student)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Falk Brunner wrote:
> @ mgiaco (Gast)
>
>>Was machen wenn man 10 Tasten braucht?
>
> Da wird man wohl oder übel den Code anpassen müssen und auf zwei Ports
> zugreifen müssen. Oder gleich ne Matrix aufbauen, ist auch in der
> Codesamlung verfügbar.
>
> MFG
> Falk

Hallo,

drei!!! Ports (einer für Matrix, zwei für je 8 Tasten) würde mich auch 
(in gleichzeitiger Interrupt Abfrage!!!) interessieren. Habe leider 
nichts hierzu gefunden - liegt das an mir - gibt es so etwas schon ?

Habe versucht Peter's Beispiel dahingehend zu erweitern ... aber 
anscheinend funzt meine Erweiterung manchmal nicht, an anderen Tagen 
problemlos ....!

Würde mich daher lieber auf professionellen Code verlassen!

Peter, hast Du vielleicht einen Hinweis, wie man so etwas professionell 
implementiert ? Wie würdest Du Deine Routine erweitern ? Matrix an sich 
ist kein Problem. Problem ist der Portwechsel ... Tasten verschiedener 
Ports im Wechsel ....!!!!

Vielen Dank im voraus,

Grüsse

Autor: Werner Dornstädter (dorni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

auch ich hab Peters Code "Debouncing" eingesetzt und meiner Anwendung 
Pollin Atmel Evaluation-Board V2) angepasst. Dies Funktioniert soweit 
ganz gut mit einer Ausnahme von KEY2.
Vielleicht liegt es daran, weil ich mit einem Pull-Down Widerstand 
arbeite und der Taster gegen VCC schaltet!

Nun will ich diesen Code besser verstehen. Wer kann mir die Funktion 
erläutern?
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; 

Vorab vielen Dank; Gruß Werner

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Werner Dornstädter wrote:

> Nun will ich diesen Code besser verstehen. Wer kann mir die Funktion
> erläutern?
>
>
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; 
>


Lauflicht über die obersten 5 LEDs.

Daran sieht man schön die Wiederholfunktion.


Peter

Autor: Bastler (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Funktioniert wie ne 1!

Aber kann mir jemand verraten, was man machen muss, damit eine Bedingung 
erst nach dem Loslassen eines langen Tastendruckes wahr wird ?

also wie kombiniert man

get_key_long(1<<KEY)

mit

get_key_release(1<<KEY)


Zusätzliche Funktion:
uint8_t get_key_release( uint8_t key_mask )
{
cli();
key_mask &= key_release;
key_release ^= key_mask;
sei();
return key_mask;
}

Zusätzliche Zeile im Entprell-Code:
...
i &= ct0 & ct1;
key_release |= key_state & i;
key_state ^= i;
...

Autor: Bastler (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das Problem ist nämlich, dass der controller durch einen Tastendruck in 
den power-down mode versetzt werden soll, und mit einem Flankeninterrupt 
wieder aufwacht.
D.h. bei einem langen Tastendruck wacht er durch die Flanke beim 
Loslassen sofort wieder auf.

Umgekehrt (get_key_short) ist es so, dass dadurch, dass der Tastendruck 
nach dem aufwachen sofort erkannt wird, gleich wieder ein power-down 
ausgelöst wird.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bastler wrote:
> Das Problem ist nämlich, dass der controller durch einen Tastendruck in
> den power-down mode versetzt werden soll, und mit einem Flankeninterrupt
> wieder aufwacht.
> D.h. bei einem langen Tastendruck wacht er durch die Flanke beim
> Loslassen sofort wieder auf.

Na dann wartste eben bis zum Loslassen:

if( get_key_long( 1<<KEY0 )){
  while( keystate & 1<<KEY0 );
  sleep();
}


Peter

Autor: Bastler (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Auch ne Möglichkeit! :-)

Autor: Hannes S. (hannestum)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Geniales Programm ,aber kann mir nochmal wer die Bedeutung der Zeile

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

erklären. Falls ich eine Taktfrequenz von 1Mhz habe dann lautet das 
Ganze ja wie folgt:

1000000/1024 * 10e-3 + 0.5 = 1.47

ich verstehe den Zusammenhang zwischen 1.47 und 10ms nicht?!

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hannes S. wrote:
> Geniales Programm ,aber kann mir nochmal wer die Bedeutung der Zeile
>
> TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);
>
> erklären. Falls ich eine Taktfrequenz von 1Mhz habe dann lautet das
> Ganze ja wie folgt:
>
> 1000000/1024 * 10e-3 + 0.5 = 1.47

Nö, da kommt 10,26 raus, also Teilerwert 10.

1MHz / 1024 / 10 = 97,6Hz = 10,2ms


Peter

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> aber kann mir nochmal wer die Bedeutung der Zeile
> TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);
> erklären.

Lies mal den ganzen Thread, dann findest du diesen Beitrag von Peter:
Beitrag "Re: Universelle Tastenabfrage"

Autor: Hannes S. (hannestum)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke Micha - hab den ganzen Thead schon gelesen - war mir aber immer 
noch nicht klar - soll vorkommen!

@Peter

Ja es is aber auch ein Unterschied ob ich:
"1MHz/1024 * 10e-3 + 0.5" oder
"1MHz  1024  10"

rechne. Bei der Zweiten Rechnung kommt schon 97,6Hz raus. Aber eben bei 
der oberen nicht. Dennoch funktionierts richtig. Irgendwie muss ich 
gerade voll am Schlauch stehen....

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Hannes S.
OK - dann nehme ich das zurück. Es gibt halt auch solche, die nicht 
alles lesen...

> Bei der Zweiten Rechnung kommt schon 97,6Hz raus. Aber eben bei der oberen
> nicht.
Was/wie rechnest du?
Wenn ich das "1MHz/1024 * 10e-3 + 0.5" (ich gebe ein: 1e6/1024*10e-3+.5) 
mit meinem Taschenrechner rechne kommt 10.265625 raus.

Autor: Hannes S. (hannestum)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mhmhhm, gott. Der Fehler lag mal wieder im Detail. Hab wohl die 
Scientific Notation schon zu lange nichtmehr benutzt..
10e-3 ist ja 10*10^-3 und nicht 10^-3
Danke für die Erklärungen ;-)

Autor: noXe (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!
Ich versuche den das Programm von Peter Dannegger für mich anzupassen 
sodass es auf einem atmega644p läuft. Den Quellcode habe ich angehängt.
Mein Problem ist jetzt dass das Programm nur auf KEY0 reagiert, nicht 
aber auf KEY1, bzw. es reagiert nur auf den 0ten Bit des Eingangsports. 
Habe es in AVR Studio simuliert kann aber dieses komisches Verhalten 
nicht einmal beschreiben.
An der Verdrahtung dürfte eigentlich nichts sein. Habe alle Anschlüsse 
schon mehrmals kontrolliert.
Kann einer bitte den Quellcode überfliegen, vielleicht habe ich ja nur 
einen dummen Fehler gemacht den ich selber nicht sehe.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
noXe wrote:
> Kann einer bitte den Quellcode überfliegen

sieht o.k. aus.

Gib doch einfach mal den Input-Port direkt aus, ob das geht.


Peter

Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

reicht es aus anstatt sei() und cli() bloß den Timer-Interrupt zu 
sperren?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
dom wrote:
> reicht es aus anstatt sei() und cli() bloß den Timer-Interrupt zu
> sperren?

Was soll denn das bringen, außer mehr Code?


Peter

Autor: dom (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich möchte nicht, dass ein bestimmter Interrupt dadurch gesperrt wird.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
dom wrote:
> Ich möchte nicht, dass ein bestimmter Interrupt dadurch gesperrt wird.

Das läßt sich aber nicht verhindern.

Immer wenn ein Interrupthandler ausgeführt wird, sind alle Interrupts 
gesperrt. Dagegen sind die 4 Zyklen für den atomaren Zugriff nur 
Pillepalle.

Jedes Programm enthält unweigerlich kurze Sperren und bisher hat das 
auch noch keinen Programmierer gestört.


Peter

Autor: tarzan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich hab exakt das gleiche Problem wie noXe mit einem Atmega644, 
irgendeine Idee?

Autor: Philipp (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielen Dank für diese Routine! Wär ich früher schon auf dieses Routine 
gestossen hätt ich mir ne Menge Arbeit und Bastelei ersparen können.

Ich habe aber noch folgendes Problem:
ich benutze eine Taste um eine Leuchte ein- und auszuschalten.
  // release after short press: task 1
  // long press: task 2
  if(get_key_short(1<<KEY_ONOFFDIM)){
    if(geraet == ein)
    geraet = aus;
  else
    geraet = ein;  
  }
  if(get_key_long(1<<KEY_ONOFFDIM)){
    //do nothing
  }

Gleichzeitig möchte ich über einen langen Tastendruck wiederholt die 
Leuchte dimmen. Jeweils abwechslungsweise hoch- und runterdimmen.
Dazu muss ich aber erkennen, wann die Taste lang gedrückt bzw. im 
Repeatmode war und wieder released wurde (um die Dimmrichtung zu 
switchen).
if(get_key_rpt(1<<KEY_ONOFFDIM)){
  if(geraet == ein) {
    if(dimmDirection == 0) {
      if(Value.m <= 95)
        Value.m += 5;
      else 
        Value.m = 100;
    }
    else {
      if(Value.m >= 5)
        Value.m -= 5;
      else 
        Value.m = 0;
    }
  }
}

Wenn ich nach dem get_key_short auch noch get_key_long abfrage, so 
erkenne ich nie einen Repeatstate.
Lasse ich aber die Abfrage get_key_long weg, so erkenne ich nach dem 
loslassen immer ein Release der Taste und get_key_short liefert mir 
einen Wert, obwohl ja die Taste zuvor lange gedrückt war.

Also ich muss folgende Zustände bzw. Zustandswechsel erkennen können:
1. Release der Taste wenn sie kurz gedrückt war
2. Repeat bei gedrückter Taste
3. Release der Taste wenn sie lange gedrückt war (und Repeats erkannt 
wurden)

kann mir da jemand helfen?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Philipp

Versuchs mal hiermit:

u8 get_key_long2( u8 key_mask )
{
  return get_key_press( get_key_rpt( key_press^key_mask ));
}


u8 get_key_long_rpt( u8 key_mask )
{
  return get_key_rpt( ~key_press^key_mask );
}


get_key_short: ein/aus
get_key_long2: Dimmrichtung wechseln
get_key_long_rpt: dimmem.


Peter

Autor: Tobi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,

zwei kleine Fragen habe ich nochmal zu deiner Routine.

1.
Wenn ich an einem Port 3 Tasten und an einem anderen Port 6 Endschalter 
habe, wie kann ich diese 9 Taster gemeinsam entprellen?
Ich denke, ich muss dann beide Ports komplett einlesen, also alle 
Variablen 2x erstellen, ist das so richtig?
2.
Wie kann ich abfragen, "solange Taste gedrückt", bzw. "solange Taste 
nicht gedrückt"? Das wäre die Abfrage der 6 Endschalter, die ich 
brauche.

Gruß Tobi

Autor: Jens Kühn (jensjk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich hab das Entprellen von 8 Tasten mal als Fingerübung (nach 20 Jahren 
Einchip und C-Pause) auf eine Matrix mit Multiplexansteuerung der LED's 
erweitert (Ziel: XPressNet Schaltpult für die Modellbahn).

So können mit 2 Port's 64 Schalter und 64 LED's mit wenig Aufwand 
angesteuert werden. Die LED's können parallel zum Taster liegen, jeweils 
an Zeilen und Spalten sollte ein Vorwiderstand zur Einhaltung der max. 
Ströme am AVR vorgeschaltet sein. Ich hab je 470 Ohm genommen, da sind 
bei 8 Zeilen die LED's hell genug.

Die Tasten landen nun in dieser Version in einem Array, die LED's werden 
ebenfalls in ein Array eingetragen und dann per Interrupt ausgegeben. Um 
Flackern zu vermeiden wurde der Timer-Int auf 2,5ms verkürzt.

Eine Erweiterung auf mehr Spalten ist ohne Probleme, evtl. kann man da 
Schieberegister verwenden. bei den Zeilen würde ich bei max. 8 bleiben, 
da sonst die Helligkeit der LED's wohl zu gering wird, auch wird das 
Einlesen und Handhaben der Tasten mit mehr 8bit schwieriger.

vg jens

Autor: Jens Kühn (jensjk)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
man kann den anhang im Bearbeiten wohl nicht anhängen, hiermit also noch 
mal anbei.

Autor: Stefan Strauß (stefan_str)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU           16000000                   // processor clock frequency geändert
#warning kein F_CPU definiert
#endif


#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    1000                        //Zeit geändert
#define REPEAT_NEXT     500                        // Zeit geändert

#define LED_DDR         DDRA
#define LED_PORT        PORTA
#define LED0            0
#define LED1            1
#define LED2            2

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 ^ ~KEY_PIN;                       // 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 beeing 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;
}

///////////////////////////////////////////////////////////////////
//
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 )
{
  KEY_DDR &= ~ALL_KEYS;                // konfigure key port for input
  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

  TCCR0 = (1<<CS02)|(1<<CS00);      // divide by 1024
  TIMSK = 1<<TOIE0;        // enable timer interrupt

  LED_PORT = 0xFF;
  LED_DDR = 0xFF;

  while(1){
    if( get_key_short( 1<<KEY1 ))
      LED_PORT ^= 1<<LED1;

    if( get_key_long( 1<<KEY1 ))
      LED_PORT ^= 1<<LED2;

                                                  // single press and repeat

    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;
    }
  }
}

Hallo
Atmega128 16Mhz (code-blocks-ubuntu.9.04-libc1.6.2.)
bei mir funktioniert nur  Eingang PINB2 (0und 1nicht)
bei gedrücktem Taster läuft die schleife durch!! wie ein lauflicht mit 
500ms
andere Anwendungen (blinken Standard funktionieren auf den ports

Autor: Stefan Strauß (stefan_str)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
> //Hallo
> // Atmega128 16Mhz (code-blocks-ubuntu.9.04-libc1.6.2.)
> //bei mir funktioniert nur  Eingang PINB2 (0und 1nicht)
> //bei gedrücktem Taster läuft die schleife durch!! wie ein lauflicht mit
> //500ms
> //andere Anwendungen (blinken Standard funktionieren auf den ports

Kann den Beitrag nicht mehr ändern als Quellcode
mache es jetzt (habs zuspät gelesen)

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stefan Strauß schrieb:
> #define REPEAT_START    1000                        //Zeit geändert
> #define REPEAT_NEXT     500                        // Zeit geändert

Eine Repeatfunktion mit 10s / 5s Wartezeit ist ziemlich witzlos.
In ein uint8_t passen außerdem nur max 255.
Max 2,55s bei 10ms Interrupt sollte wohl reichen.


Peter

Autor: Stefan Strauß (stefan_str)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter
der 128er läuft mit 16Mhz
wenn ich hier nichts ändere kann ich nicht kontrolliert die LED`s weiter 
tasten ( rennt einfach durch) jetzt hat er eine Schaltzeit von ca 250ms 
bei dem wert wo 1000 steht.
muß ich die Zeiten wo anders ändern?
gruß Stefan

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stefan Strauß schrieb:
 der 128er läuft mit 16Mhz

Lies Dir den Thread in Ruhe durch, wo die Quarzfrequenz festgelegt wird.


> bei dem wert wo 1000 steht.

Ich hab Dir doch schon gesagt, daß das Mumpitz ist.
Nimm auch mal die Compilerwarnungen ernst:
C_TAST.C:58: warning: large integer implicitly truncated to unsigned type


> muß ich die Zeiten wo anders ändern?

Warum willst Du 10s?


Sind Deine Tasten gegen GND?
Daß KEY0 nicht geht, liegt einfach daran, daß Du in garnicht verwendest.
Ich hab den Eindruck, Du verstehst überhaupt nicht, was Du da schreibst.
Hast Du vorher schonmal in C programmiert?


Peter

Autor: Arwed Reichel (arwedo)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo (vor allem Jens),
der Thread ist genau, was ich suchte. Vor allem das Feature mit 
"Lange-Druecken-Erkennung" finde ich cool. Ich will auch eine kleine 
Tastaturmatrix ansteuern, deshalb habe ich mir die Codeanpassung von 
Jens Kuehn (vom Februar) hergenommen. Bei mir funktioniert's aber (nach 
Murphy) natuerlich noch nicht so ganz.

Zum Verstaendnis habe ich an Jens folgende Fragen:
1) KEY0...2 und ZEILE0...2 sind doch m.E. synonym; hast Du die wegen des 
Bezugs zu Peters Originalcode dringelassen?
2) Meine Zeilenleitungen sind PD2...PD7, also muss ich doch auch bei 
KEY0...5 und bei ZEILE0...5 die 2...7 eintragen, oder?

Hintergrund: Ich will ueber Kippschalterchen, die eine Ruhestellung 
haben und nach oben und unten getastet werden und einen ATMega(8) und 
Servos die Weichen meiner Modellbahn schalten. (Die Schalter-Bedienung 
finde ich ziemlich intuitiv und Vollautomatisierung will ich (noch) 
nicht.) Dafuer wollte ich "oben" und "unten", also PB0 und PB1, als 
Spalten an die Schalterchen anlegen und die jeweiligen mittleren 
Schalterkontakte als Zeileneingaenge, also PD2...PD7, abfragen.

Der Effekt ist jetzt ganz komisch: zum Testen habe ich einen solchen 
Schalter angeschlossen, der eine Lumi nach oben an- und nach unten 
ausschalten soll. An geht bei jedem dritten mal, manchmal auch bei jedem 
vierten, manchmal geht's aber da auch aus, wo's eigentlich nur angehen 
soll ...

Muss wohl noch etwas 'rumdebuggen. Dankeschoen auf alle Faelle schonmal 
an Peter und Jens fuer den coolen Code.
Viele Gruesse!

Autor: Jens Kühn (jensjk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Arwed,

die lange Tastenerkennung hab ich nicht mehr drin, ansonsten habe ich 
aber an dem Code noch viel geändert, so wie er oben steht kann er nicht 
so richtig gehen. Ich muss es aber noch mal aufbereiten (bisher gab es 
nicht so viel Interesse) und stelle es dann hier noch mal ein. ich 
hoffe, ich schaff es am Wochenende.

Ich setze es übrigens auch für die Moba ein, hab es allerdings als 
Schaltpult an einer Zentrale (opendcc.de) hängen und kann dann auch ohne 
PC weiter meine Signale und Weichen schalten.

viele Grüße

jens

Autor: Jens Kühn (jensjk)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
hab es gleich noch gemacht ...

in der zip ist das AVR-projekt und eine PDF als Schaltplan. Sorry, der 
Code ist etwas unordentlich. Es gibt nun noch ein Array welches einen 
Blinkmodus für die LED's einbaut.

Bei einem muss ich Dich aber enttäuschen: Kippschalter gehen nicht, weil 
Du damit eine Spalte/Zeile 'tot legst' das geht bei einer Matrix halt 
nicht.

vg jens

Autor: Arwed Reichel (arwedo)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke Jens,
das werde ich probieren. Dass die Erkennung des lange Drueckens nicht 
mehr drin ist, ist natuerlich schade. Ich werde mich mal dran versuchen. 
Muesste beim Vergleich mit Peters Originalcode ja 'rauszufinden sein.

Aber dass Dein (alter) Code nicht geht, kann ich nicht bestaetigen. 
Mittlerweile habe ich den Fehler gefunden: Ich hatte ein Quarz-Gehaeuse 
so dicht an den Pins des ATMega, dass der "so'n bissel" Kurzschluss 
gemacht hat ... Sonst tut's aber nun!

Die Kippschalter sind eigentlich Kipptaster, also mit Nullstellung und 
je einer Taststellung oben und unten. Das passt schon. Die Mitte eines 
solchen Tasters kommt an je eine Zeile und "oben" und "unten" gemeinsam 
an die beiden Spalten.

Danke auch fuer den Schaltplan; mit den LED's war mir das noch nicht 
ganz klar.

Viele Gruesse von Arwed

p.s.: Aber kann man nicht doch die KEY-Definitionen weglassen und 
stattdessen ueberall die ZEILE-Definitionen? Also codetechnisch ja 
sowieso, aber ich meine auch inhaltlich? Was bei Peter die KEYs waren, 
sind doch nun die ZEILEn, dachte ich ...

Autor: Jens Kühn (jensjk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
[quote]Aber dass Dein (alter) Code nicht geht, kann ich nicht 
bestaetigen.
[/quote]
ja, prinzipiell ging er schon. Geändert hab ich glaub ich noch etwas 
weil sonst der Interrupt meine Datentransferroutinen blockierte und in 
dem alten code flackern die LED's glaub ich noch.

[quote]Die Kippschalter sind eigentlich Kipptaster, also mit 
Nullstellung und
je einer Taststellung oben und unten. Das passt schon. Die Mitte eines
solchen Tasters kommt an je eine Zeile und "oben" und "unten" gemeinsam
an die beiden Spalten.[/quote]
das passt gut, der Verdrahtungsaufwand wird dadurch ja noch geringer

[quote]Aber kann man nicht doch die KEY-Definitionen weglassen und
stattdessen ueberall die ZEILE-Definitionen? Also codetechnisch ja
sowieso, aber ich meine auch inhaltlich? Was bei Peter die KEYs waren,
sind doch nun die ZEILEn, dachte ich ...[/quote]

das ist doch nur eine Frage was für Dich besser verständlich ist. Ich 
hatte es dann doch auf den KEY0 ... gelassen (so nach dem Motto: Taste 0 
in der Spalte X). Du kannst einfach alle KEY0 durch ZEILE0 ersetzen, das 
wird auch gehen. Und die Definition selbst isst ja kein Brot ... da kann 
man auch beide Varianten definieren und im Code dann je nach besserer 
Verständlichkeit verwenden.

Zum Schaltplan evtl. noch ein Hinweis: die Vorwiderstände kannst Du 
evtl. noch größer machen, wenn Deine LED's hell genug sind. Ich hab 
Taster mit eingebauter LED, die funzeln recht trübe. Gegenüber einer 
normalen Ansteuerung brauchst Du aber immer etwas mehr Strom, da die ja 
nur 1/8 der Zeit Strom bekommen.

viel Spaß

jens

Autor: Arwed Reichel (arwedo)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
ich habe mir nochmal Jens' Code hergenommen und mit Peters verglichen,
weil ich (noch) keine Lumis ueber den Tasten brauche, aber die
Long-Funktion haben wollte. Dabei habe ich festgestellt, dass Jens die
ct0 und ct1 bei jdem ISR-Durchlauf auf 0 gesetzt hat; geht denn das in
Ordnung? Eigentlich hatte ich es so verstanden, dass die ueber die ISR
hinaus ihre Werte behalten sollen, oder? Und die muessen daher doch auch
einmal je Spalte dasein?!
Ich habe mich nun nochmal dran versucht und in Zeitlupe debuggt und habe
nun folgende ISR:
ISR( TIMER0_OVF_vect ){
  static uint8_t ct0[SPALTENANZAHL], ct1[SPALTENANZAHL], rpt;
  uint8_t i;
  uint8_t key_mpex;    //die aktive Tasten-Spalte

  TCNT0 = TIMER0_STARTVALUE;
  //jetzt alle Spalten durcharbeiten
  for( key_mpex=0; key_mpex < SPALTENANZAHL; ++key_mpex ){
    i = 0;
    SPALTE_PORT &= ~(1<<(spalten_pin[key_mpex])); //aktive Spalte auf 0 
    i = key_state[key_mpex] ^ ~ZEILE_PIN;         // key changed ?
    ct0[key_mpex] = ~( ct0[key_mpex] & i );       // reset or count ct0
    ct1[key_mpex] = ct0[key_mpex] ^ (ct1[key_mpex] & i); // dito ct1
    i &= ct0[key_mpex] & ct1[key_mpex];    // count until roll over ?
    key_state[key_mpex] ^= i;             // then toggle debounced state
    key_press[key_mpex] |= key_state[key_mpex] & i; // 0->1: key pressed
    if( (key_state[key_mpex] & REPEAT_MASK) == 0 )  // check repeat fct.
      rpt = REPEAT_START;                           // start delay
    if( --rpt == 0 ){
      rpt = REPEAT_NEXT;                            // repeat delay
      key_rpt[key_mpex] |= key_state[key_mpex] & REPEAT_MASK;
    }   
    SPALTE_PORT |= (1<<(spalten_pin[key_mpex])); //Spalte deaktivieren
  }
}
Das tut soweit wunderbar -- solange ich nur mit get_key_press() abfrage;
aber get_key_rpt liefert nix und get_key_long verhaelt sich entweder wie
get_key_press oder gar nicht.
Ich habe den Repeat-Trick noch nicht ganz verstanden; muss da nicht auch
noch eine Repeat-Variable je Spalte rein, also so aehnlich wie
key_state?
Viele Gruesse ...

Autor: MarkusK (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

eigendlich ein super Teil :) Leider funktioniert es überhaupt nicht 
mehr, seit dem ich einen 14,7456MHz Quarz an meinem ATmega128 habe.
Im Simulator (2) wird die Timer0 Routine, laut Stopwatch, nicht alle 
10ms sondern alle 1.25ms aufgerufen.
F_CPU steht auch auf 14745600UL.

Mit 1MHz hat es super funktioniert.

MfG
Markus

Autor: MarkusK (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Oh, habe das wichtigste Vergessen: Wenn ich zB auf Taster 2 drücke 
flimmern die LEDs nurnoch. Auf Taster 1 funktioniert lang/kurz drücken 
auch nicht so richtig; man muss ganz kurz drauf'hacken', damit man LED 1 
zum Leuchten bringt.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
MarkusK schrieb:
> F_CPU steht auch auf 14745600UL.

Versuchs mal mit XTAL.


Peter

Autor: MarkusK (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wie? ich hab den quarz an XTAL angeschlossen !?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Versuchs mal mit XTAL ... statt F_CPU.

Du darfst Dir das Programm ruhig durchlesen. Dann wirst Du merken, daß 
ich XTAL verwende, aber nirgends F_CPU.


Peter

Autor: Marco Glatz (marcoglatz)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hallo,

hab heute mein avr starterboard von pollin bekommen und damit etwas 
rumgespielt (verwende einen atmega32). wenn ich nun eine taste extrem 
schnell nacheinander drücke (man muss sich schon etwas anstrengen um das 
hinzubekommen) macht mein atmega einen reset!?


gruß,
marco

Autor: Werner B. (werner-b)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das liegt an der "Buggy" Beschaltung der Tasten auf dem Pollin Board.
Siehe Beitrag "Pollin AVR Board Fehler beim drücken der Taster / Qualität der Bauteile"

Autor: Hans-Peter (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich wollt mich erstmal für die gute Entprellroutine bei Peter bedanken.

Um kurz zu erklären was ich vorhabe, es sollen mit 2 Tasten ein PWM 
Kanal bei kurzem Tastendruck geschaltet und bei langen Tastendruck 
gedimmt werden. Also Taster 0 für Einschalten und aufwärts Dimmen und 
Taster 1 für Ausschalten und abwärts Dimmen.

Das Problem auf das ich gestoßen bin ist, dass immer beim Loslassen nach 
dem Dimmen weiterhin ein kurzer Tastendruck registriert wird und so nach 
dem Dimmen das schalten ausgeführt wird. Beim aufwärts Dimmen ist das 
nicht schlimm, weil die Leds ja bereits an sein sollten, aber beim 
Abwärts dimmen werden diese ja dann ausgeschaltet was ich vermeiden 
möchte.

Aus einem vorherigen Beitrag, der ähnliche Wünsche wie ich beschreibt, 
habe ich die Funktion get_key_long_rpt benutzt. Leider hat der 
Fragesteller (Philipp) kein Feedback auf die von Peter gepostete Lösung 
gegeben, deswegen weiss ich nicht ob sie bei Ihm funktioniert hat.

Ich würde mich freuen wenn Ihr mir helfen könntet.

Meinen Quellcode hab ich angehängt.

Zum Device, es handelt sich um einen Atmega 48A mit 16MHz Clock.

Ich dank euch schonmal für die Antworten.

Grüße
Hans-Peter

Autor: Hans-Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich bins nochmal, hat denn keiner eine Idee wieso nach dem Erkennen des 
wiederholten langen Drucks auch ein kurzer Tastendruck erkannt wird?

Grüße
Hans-Peter

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans-Peter schrieb:
> Hallo,
>
> ich bins nochmal, hat denn keiner eine Idee wieso nach dem Erkennen des
> wiederholten langen Drucks auch ein kurzer Tastendruck erkannt wird?
>
> Grüße
> Hans-Peter

Du mußt dann alle 3 Funktionen aufrufen:
if( get_key_short( xxx )){
...
}
if( get_key_long2( xxx ) || get_key_long_rpt( xxx )){
...
}

Versuch mal zu beschreiben, warum.


Peter

Autor: eku (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich entprelle 4 tasten mit Peters Routine. Allerdings schaffe ich es 
nicht, mehr als eine Taste gleichzeitig erkannt zu bekommen obwohl ich 
zwei nebeneinander liegende Tasten praktisch mit einem Finger betätige. 
Wie muß man den Source verändern, das mehrere Tasten erkannt werden?

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
eku schrieb:
> Wie muß man den Source verändern, das mehrere Tasten erkannt werden?
Vielleicht zeigst du uns erstmal deinen Code!?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
eku schrieb:
> Ich entprelle 4 tasten mit Peters Routine. Allerdings schaffe ich es
> nicht, mehr als eine Taste gleichzeitig erkannt zu bekommen obwohl ich
> zwei nebeneinander liegende Tasten praktisch mit einem Finger betätige.

Du müßtest beide innerhalb des gleichen 10ms-Fensters drücken, das ist 
recht sportlich.
Für den MC drückst Du sie also nacheinander.

> Wie muß man den Source verändern, das mehrere Tasten erkannt werden?

Du könntest eine als Shifttaste definieren, d.h. kurz vorher gedrückt 
halten:
  if( get_key_press( 1<<USER_KEY0 )){
    if( key_state & 1<<SHIFT_KEY ){
      // shift + userkey0
    }else{
      // only userkey0 
    }
  }


Peter

Autor: eku (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Du müßtest beide innerhalb des gleichen 10ms-Fensters drücken, das ist
> recht sportlich. Für den MC drückst Du sie also nacheinander.

Genau das ist mein Problem. Ich möchte aber nicht eine Taste mit einer 
Spezialfunktion (SHIFT) belegen, denn es soll egal sein, welche zwei 
Tasten aus meiner Sicht "gleichzeitig" gedrückt werden. Der MC soll nur 
zwischen einer Taste und zwei Tasten unterscheiden, d.h. wenn zwei 
Bits bei get_key_press() gesetzt sind.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das Problem ist, die CPU kann nicht Deine Gedanken lesen.

Woher soll sie den wissen, daß Du etwa 300ms später eine 2.Taste drücken 
wirst und das dann als 2-Tastendruck erkannt werden soll und der 300ms 
vorher erkannte 1-Tastendruck ungültig gewesen war?

Du mußt einen eindeutige Regel definieren, wie die CPU etwas 
unterscheiden soll.
Mach Dir mal nen Programmablaufplan und dann erst kann man den 
implementieren.

Bedenke auch, daß ältere Menschen deutlich länger benötigen werden, 2 
Tasten gleichzeitig (innerhalb eines Zeitintervalls) zu drücken. Bzw. ob 
das überhaupt benutzerfeundlich (ergonomisch) ist.

Du wirst deshalb in kommerziellen Geräten keine solche Bedienung finden.
Da haben sich für Mehrfachbelegung die Sondertasten bewährt, deren 
Funktion nur durch die Reihenfolge eindeutig bestimmt ist und damit die 
unterschiedlichen motorischen Fähigkeiten verschiedener Menschen die 
Bedienung nicht behindern/verhindern.


Peter

Autor: Thomas (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie das funktionieren soll verstehe ich leider immer noch nicht:
u8 get_key_long2( u8 key_mask )
{
  return get_key_press( get_key_rpt( key_press^key_mask ));
}

u8 get_key_long_rpt( u8 key_mask )
{
  return get_key_rpt( ~key_press^key_mask );
}


...


if( get_key_short( xxx )){
LED_PORT ^= 1<<LED1;
}
if( get_key_long2( xxx ) || get_key_long_rpt( xxx )){
LED_PORT ^= 1<<LED2;
}

Ein langer Tastendruck lässt LED2 blinken, aber schaltet beim Loslassen 
noch die LED1 um.
Wenn ich die vorangegangen Beiträge richtig verstanden habe, sollte das 
in diesem Beispiel doch nicht passieren, oder?

Kann mir jemand nochmal einen Tip dazu geben?

Danke,
Thomas

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann er das nicht durch eine Kombination aus get_key_press und 
get_key_repeat lösen?

Aber trotzdem gilt PAP zeichnen und entsprechend programmieren...

Autor: thomas (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Micha schrieb:
> Kann er das nicht durch eine Kombination aus get_key_press und
> get_key_repeat lösen?

Nun ja, die Lösung oben ist ja eine Kombination aus diesen beiden 
Routinen.
Sie funktioniert ja auch soweit, nur wenn ich die Taste nach langem 
Drücken loslasse, wird offensichtlich nochmal ein kurzer Tastendruck 
augelöst.
Ich verstehe einfach nicht warum das so ist...

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
thomas schrieb:
> Sie funktioniert ja auch soweit, nur wenn ich die Taste nach langem
> Drücken loslasse, wird offensichtlich nochmal ein kurzer Tastendruck
> augelöst.

Ja, da hat sich ein Schreibfehler eingeschlichen. Das EXOR ist Unsinn, 
muß ein AND sein.
Hier mal ein funktionierender Code:

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                                                                      */
/************************************************************************/

//                              Target: ATtiny13

#include <avr/interrupt.h>
#include <util/atomic.h>


#define F_CPU           1.2e6           // 1.2MHz

#define KEY_PIN         PINB
#define KEY_PORT        PORTB
#define KEY0            4

#define LED_DDR         DDRB
#define LED_PORT        PORTB
#define LED0            0
#define LED1            1
#define LED2            2
#define LED3            3


#define REPEAT_MASK     (1<<KEY0)       // repeat: key0
#define REPEAT_START    50              // after 500ms
#define REPEAT_NEXT     20              // every 200ms


uint8_t key_state;                      // debounced and inverted key state:
                                                // bit = 1: key pressed
uint8_t key_press;                      // key press detect
uint8_t key_rpt;                        // key long press and repeat


ISR( TIM0_COMPA_vect )                          // every 10ms
{
  static uint8_t ct0 = 0xFF, ct1 = 0xFF, rpt;
  uint8_t i;

  i = key_state ^ ~KEY_PIN;                     // 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;
  }
}


uint8_t get_key_press( uint8_t key_mask )
{
  ATOMIC_BLOCK(ATOMIC_FORCEON){
    key_mask &= key_press;                      // read key(s)
    key_press ^= key_mask;                      // clear key(s)
  }
  return key_mask;
}


uint8_t get_key_rpt( uint8_t key_mask )
{
  ATOMIC_BLOCK(ATOMIC_FORCEON){
    key_mask &= key_rpt;                        // read key(s)
    key_rpt ^= key_mask;                        // clear key(s)
  }
  return key_mask;
}


uint8_t get_key_short( uint8_t key_mask )
{
  uint8_t i;

  ATOMIC_BLOCK(ATOMIC_FORCEON)
    i = get_key_press( ~key_state & key_mask );
  return i;
}


uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}


uint8_t get_key_long_r( uint8_t key_mask )      // if repeat function needed
{
  return get_key_press( get_key_rpt( key_press & key_mask ));
}


uint8_t get_key_rpt_l( uint8_t key_mask )       // if long function needed
{
  return get_key_rpt( ~key_press & key_mask );
}


int main( void )
{
  TCCR0A = 1<<WGM01;                                    // Mode 2. CTC
  TCCR0B = 1<<CS02 | 1<<CS00;                           // F_CPU / 1024
  OCR0A = F_CPU / 1024.0 * 10e-3 - 0.5;                 // 10ms interrupt
  TIMSK0 = 1<<OCIE0A;

  LED_PORT = 1<<LED0 | 1<<LED1 | 1<<LED2 | 1<<LED3;     // LEDs off
  LED_DDR = 1<<LED0 | 1<<LED1 | 1<<LED2 | 1<<LED3;
  KEY_PORT |= 1<<KEY0;                                  // Pullup on
  sei();

  for(;;){                                              // main loop

    if( get_key_short( 1<<KEY0 ))
      LED_PORT ^= 1<<LED0;

    if( get_key_long_r( 1<<KEY0 ))
      LED_PORT ^= 1<<LED1;

    if( get_key_rpt_l( 1<<KEY0 ))
      LED_PORT ^= 1<<LED2;
  }
}


Peter

Autor: eku (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Micha schrieb:
> Kann er das nicht durch eine Kombination aus get_key_press und
> get_key_repeat lösen?

Was ist mit
   if (get_key_long (maske_über_alle_tasten) == zwei_bits_gesetzt)
   {
      aktion für zwei tasten
   }

Würde das funktionieren?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Anmerkung:

Erlaubte Funktionen einer Taste:

- get_key_press()

- get_key_rpt()

- get_key_press() mit get_key_rpt()

- get_key_short() mit get_key_long()

- get_key_short() mit get_key_long_r() und get_key_rpt_l()


Peter

Autor: Peter Dannegger (peda)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Ich weiß nicht, warum alle so scharf auf 2-Tastenbedienung sind.
Man muß einfach nur logisch denken, wie ein MC das erkennen soll, ohne 
Hellseherei.

Man kann es mit meinen Funktionen erreichen. Gleichzeitig bedeutet dann, 
innerhalb der Zeit zur Langdruckerkennung. Man kann also einen 
Einzeldruck nicht mehr sofort erkennen.

  for(;;){                                              // main loop
    switch( get_key_long(  1<<KEY0 | 1<<KEY1 ) |
            get_key_short( 1<<KEY0 | 1<<KEY1 )){

      case 1<<KEY0:             LED_PORT ^= 1<<LED0; break;

      case 1<<KEY1:             LED_PORT ^= 1<<LED1; break;

      case 1<<KEY0 | 1<<KEY1:   LED_PORT ^= 1<<LED2; break;
    }
  }

Für 2-Tastendruck muß also immer lange gedrückt werden.
Kurze Drücke werden als einzeln gewertet. Will man das nicht, muß man 
get_key_short aus dem Switch herausnehmen, aber man muß es trotzdem 
aufrufen. Es wird nur nicht ausgewertet.


Aber wie schon gesagt, es ist weder sinnvoll, noch bedienerfreundlich.

Ich kann mir eigentlich nur eine einzige Anwendung denken:
Man hat eine gefährliche Maschine und will verhindern, daß der Bediener 
hineingreift und zu Schaden kommt. Deshalb muß er mit je einer Hand eine 
Taste drücken.
Damit der Bediener nun aber nicht eine Taste aus Bequemlichkeit 
blockiert, muß er sie innerhalb einer bestimmten Zeit gleichzeitig 
drücken.


Peter

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Verbesserte Version:
  for(;;){                                              // main loop
    switch( get_key_long(  1<<KEY0 | 1<<KEY1 ) |
            get_key_short( 1<<KEY0 | 1<<KEY1 )){

      case 1<<KEY0:             LED_PORT ^= 1<<LED0; break;

      case 1<<KEY1:             LED_PORT ^= 1<<LED1; break;

      default:
                if((key_press & (1<<KEY0 | 1<<KEY1)) != (1<<KEY0 | 1<<KEY1))
                  break;
                get_key_press( 1<<KEY0 | 1<<KEY1 );

      case 1<<KEY0 | 1<<KEY1:   LED_PORT ^= 1<<LED2; break;
    }
  }


Peter

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So, jetzt noch einfacher, mit ner extra Funktion für die 2 Tasten 
Erkennung.
Man kann auch auswählen, ob der Druck beider Tasten innerhalb einer 
bestimmte Zeit erfolgen soll (#define TIMEOUT)

uint8_t get_key_common( uint8_t key_mask )
{
  return get_key_press((key_press & key_mask) == key_mask ? key_mask : 0);
}

// ...

//#define TIMEOUT

  for(;;){                                              // main loop
#ifdef TIMEOUT
    if( get_key_short( 1<<KEY0 ) || get_key_long( 1<<KEY0 ))
      LED_PORT ^= 1<<LED0;

    if( get_key_short( 1<<KEY1 ) || get_key_long( 1<<KEY1 ))
      LED_PORT ^= 1<<LED1;
#else
    if( get_key_short( 1<<KEY0 ))
      LED_PORT ^= 1<<LED0;

    if( get_key_short( 1<<KEY1 ))
      LED_PORT ^= 1<<LED1;
#endif
    if( get_key_common( 1<<KEY0 | 1<<KEY1 ))
      LED_PORT ^= 1<<LED2;
  }


Peter

Autor: eku (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter,

Peter Dannegger schrieb:
> So, jetzt noch einfacher, mit ner extra Funktion für die 2 Tasten
> Erkennung.

vielen Dank. Du hast mir sehr geholfen.

Autor: thomas (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Hier mal ein funktionierender Code:

Danke Peter, funktioniert perfekt!

Gruß
Thomas

Autor: Heribert (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Man kann auch auswählen, ob der Druck beider Tasten innerhalb einer
> bestimmte Zeit erfolgen soll (#define TIMEOUT)

Wo wird denn im Quelltext der Wert von TIMEOUT ausgewertet? Also wo wird 
berücksichtigt, ob ich 10 oder 100 oder 1000 eingebe?

Ansonsten prima! Die Funktion fehlte noch - deine Tastenentprellung ist 
wirklich der Hammer, PeDa! Danke sehr!

Autor: Fabian B. (fabs)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

@peda: Du hattest ja beschrieben welche Funktionen zusammen zulässig 
sind:

Peter Dannegger schrieb:
> Erlaubte Funktionen einer Taste:
>
> - get_key_press()
>
> - get_key_rpt()
>
> - get_key_press() mit get_key_rpt()
>
> - get_key_short() mit get_key_long()
>
> - get_key_short() mit get_key_long_r() und get_key_rpt_l()

Sehe ich das richtig, dass *get_key_long_r()* nur die long-Funktion ist 
wenn man auch noch *get_key_rpt_l()* (Repeat während lang gedrückt) 
nutzen möchte?

Ich suche nach einer Möglichkeit das Loslassen einer Taste, die zuvor 
lang gedrückt war zu detektieren. Ein Repeat beim lang gedrückt halten 
müsste ich hier nicht mehr detektieren können.

Das müsste doch möglich sein, oder?
Vielleicht hat jemand das ja schonmal in eine Funktion gegossen oder 
kann mir sagen wie ich dazu die Aufrufe kombinieren muss?

Vielen Dank schonmal!

Gruß
Fabian

Autor: Fabian B. (fabs)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gibts dazu keine Lösung? Ich hab nun mittlerweile alles hier im Thread 
an Funktionskombinationen gefundene ausprobiert, aber ohne Erfolg.
Nicht mal die "fehlerhafte" Variante von "Thomas" ( 
Beitrag "Re: Universelle Tastenabfrage" ), die ja eigentlich 
das richtige tun sollte, geht nicht -> sie funktioniert bei mir gar 
nicht.

Nochmal zusammengefasst muss ich auf einer Taste folgendes detektieren.
1) Taste kurz gedrückt -> ok
2) Taste lang gedrückt -> ok
3) Taste losgelassen nach lang gedrückt -> geht nicht

Alternative wäre noch einfach das loslassen (egal ob nach kurz oder 
lang) der Taste detektieren zu können, dann könnte ich immernoch anhand 
interner Variablen die Aktion korrekt auswählen.

Ich wäre dankbar, wenn's doch noch eine Möglichkeit gibt, das mit Pedas 
Standardfunktionen umzusetzen.

Gruß
Fabian

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was willst du denn damit erreichen? 3 Funktionen per Taste? Geht eh 
nicht, da du die Taste sonst nach einem langen Druck nicht mehr 
loslassen darfst.

Autor: Fabian B. (fabs)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nein eigentlich gibts nur zwei Funktionen für den Nutzer pro Taste: kurz 
gedrückt und lang gedrückt.
Es wird ein externes Gerät angesteuert (CD-Player). Auf einer Taste soll 
nun bei kurzem Druck Skip und bei langem Druck Spulen liegen. Soweit so 
einfach.
Es ist aber so, dass ich beim Spulen nicht immer wieder "spulen" schicke 
sondern nur einmal "fang an zu spulen" sobald ein langer Druck erkannt 
wurde und ein "spiel wieder normal" wenn dann wieder losgelassen wird.
Hoffe das ist verständlich.

Ich habe es jetzt aber über eine "illegale Funktionskombination" gelöst:
get_key_short und get_key_rpt.

Hier muss ich mir nur über eine interne Variable merken ob ich spule 
(damit beim repeat nicht immer wieder das Kommando gesendet wird. Da 
get_key_rpt den Key nicht zurücksetzt wird beim loslassen direkt nochmal 
get_key_short ausgelöst. Hier kann ich nun ebenfalls über die interne 
Variable erkennen ob ich skippen soll oder das Spulen beende.

Schöner wäre natürlich eine eigene Funktion 
"get_key_release_after_long_press" und dann die Nutzung von 
get_key_short und get_key_long. Aber ich habe dafür keine Möglichkeit 
sehen können.

Gruß
Fabian

Autor: Jonas P. (jox)
Datum:

Bewertung
1 lesenswert
nicht lesenswert
Hallo Leute,

erstmal vielen Dank an Peter für den erstklassigen Code!

Um mir und hoffentlich noch anderen die Entscheidung zu erleichtern 
welche Kombination von Abfragen die geeignete ist, habe ich
mal ein paar Grafiken gemacht, welche die verschiedenen Funktionsweisen 
veranschaulichen. Im Grunde sind es 3 Modi, die man verwenden kann. Die 
Grafiken stellen den Ablauf einer Folge von 3 Tastendrücken dar. Ein 
kurzer, ein langer und wieder ein Kurzer. In der ersten Grafik sind auch 
die Zeitintervalle REPEAT_START und REPEAT_NEXT gekennzeichnet.

Anmerkungen:
- keystate ist bei gedrückter Taste oben, ansonsten unten.
- "X" bedeutet ein Tastenereignis wurde erkannt (die entsprechende 
Funktion liefert != 0).
- Der aufmerksame Beobachter wird feststellen, dass eine Funktion 
gelistet ist, die nicht existiert. Nämlich 'key_release'.
Die lässt sich mit ein paar Handgriffen in den Code von Peter einbauen. 
Wie das geht zeige ich in seperatem Post.


Modus 1 ('get_key_press' mit 'get_key_rpt')
===========================================

           Zeitachse ---->
                 __      _________________      __
keystate    ____/  \____/                 \____/  \____
key_press   ----X-------X----------------------X-------
key_rpt     --------------------X--X--X--X-------------
key_release -------X----------------------X-------X----
                        |       |  |  |
                        |       |__|__|
                        |       | \ /
                        |_______|  REPEAT_NEXT
                              \
                               REPEAT_START


Modus 2 ('get_key_short' mit 'get_key_long')
============================================
                 __      _________________      __
keystate    ____/  \____/                 \____/  \____
key_short   -------X------------------------------X----
key_long    --------------------X----------------------
key_release -------X----------------------X-------X----


Modus 3 ('get_key_short' mit 'get_key_long_r' und 'get_key_rpt_l')
==================================================================
                 __      _________________      __
keystate    ____/  \____/                 \____/  \____
key_short   -------X------------------------------X----
key_long_r  --------------------X----------------------
key_rpt_l   -----------------------X--X--X-------------
key_release -------X----------------------X-------X----


Wichtig zu wissen ist vielleicht noch, dass 'get_key_long_r' und 
'get_key_rpt_l' immer zusammen abgefragt werden müssen,
auch wenn für ein Fall keine Verwendung ist. Für sich alleine liefern 
die Funktionen keine brauchbaren Ergebnisse (auch nicht zusammen mit 
'get_key_short').

'get_key_release' kann man in allen Modi verwenden.

Grüße
Jonas

Autor: Jonas P. (jox)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie angekündigt hier die 'get_key_release' Funktion. Drei Schritte sind 
nötig.


1. Zu den globalen Variablen den release buffer hinzufügen:


Nach der Zeile
volatile uint8_t key_press;   // key press detect
folgendes einfügen:
volatile uint8_t key_release; // key release detect


2. In der ISR den buffer aktualisieren:


Nach der Zeile
key_press |= key_state & i;    // 0->1: key press detect
diese Zeile einfügen:
key_release |= ~key_state & i; // 1->0: key release detect


3. Und zu guter Letzt die Funktion um den release abzufragen:


Bei den anderen Funktionen einfügen:
uint8_t get_key_release( uint8_t key_mask )
{
  cli();                     // read and clear atomic !
  key_mask &= key_release;   // read key(s)
  key_release ^= key_mask;   // clear key(s)
  sei();
  return key_mask;
}

Gruß
Jonas

Autor: Christian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Wenn der Timer0 schon durch PWM belegt ist, kann man dann einfach einen 
der beiden anderen nehmen oder gibt es einen besonderen Grund für die 
Verwendung des "Nullers"?

Ich habe das Tutorial gelesen und etwas experimentiert und auch im 
Datenblatt gestöbert - so richtig schlau bin ich aber noch nicht draus 
geworden...

Dankeschön!

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Christian schrieb:
> Wenn der Timer0 schon durch PWM belegt ist, kann man dann einfach einen
> der beiden anderen nehmen oder gibt es einen besonderen Grund für die
> Verwendung des "Nullers"?

Wie kommst Du denn darauf, daß es nicht ginge?

Du brauchst ein Zeitintervall von etwa 5..50ms.


Peter

Autor: Karsten K. (karsten42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin Moin!
Ich möchte die get_key_common() Funktion nutzen um durch langes drücken 
zweier Tasten in den "Programmier-mode" zu gelangen.
Die Funktion reagiert aber auch schon auf kurzen Tastendruck. Wie kann 
ich die Funktion erweitern/verändern, sodaß nur auf langes drücken 
zweier Tasten reagiert wird?

10000000 * 10^12 Dank für eure Hilfe

Karsten

Autor: Christian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Wie kommst Du denn darauf, daß es nicht ginge?

Was jetzt? Den Timer trotzdem auch dafür nutzen oder einen anderen 
Timer?

Der PWM-Kram ist ja relativ komplex, da frage ich lieber mal nach, bevor 
da was kollidiert. Und ich will mich da ja richtig einarbeiten und es 
verstehen und nicht einfach rum frickeln...

> Du brauchst ein Zeitintervall von etwa 5..50ms.

Ich kläre erstmal mit der bereits laufenden Software, welche (und wie) 
Timer genutzt und ob welche frei sind. Da die Timer ja auf zig Wegen 
angesprochen und gesteuert werden und ich da noch nicht soo viel gemacht 
habe, ist das etwas schwierig für mich. Aber ich beisse mich da schon 
durch.

Gibt es zur Analyse von fremden Programmen z.B. in Eclipse ein Plugin 
oder gar was Eingebautes, um die genutzten Ressourcen eines AVR anzeigen 
zu lassen?

So Interessehalber: wie machen das eigentlich die Hersteller z.B. von 
großen Lichtsteuerungen? Gibt es da Spezialbauteile für die Entprellung 
von 200 Tastern oder macht das der uC auf einer A...backe nebenher?

Autor: Christian (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also bei mir hat sich das Thema erstmal erledigt bzw. "verunwichtigt", 
ich lege es erstmal auf Eis.

Für andere Noobs wie mich wäre eine Antwort bei Gelegenehit allerdings 
sicher trotzdem interessant...

Wie für mich, wenn ich doch mal wieder damit anfange ;)

Autor: Christoph (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wollt mich nur kurz für die Routine bedanken,
funktioniert einwandfrei!

Danke Peter :)

Beste Grüße
Christoph

Autor: Martin Sv (sv_martin)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo an alle,

Ich habe den Code (Orginal Peter) an einen ATmega 8515 angepasst die 
KEY's liegen auf dem DDRC, die LED's auf dem DDRA
Die Funktion ist bei diesem µC auch gegeben.
KEY0 keine Funktion; KEY1 kurz/lang die Aktivierung von LED0/1;
KEY2 bei Betätigung laufen die LED's 2....7 je nach Takt und prescaler.

Nun hab ich den 8515 gegen einen ATmega 16 getauscht, weil ich einen 
weiteren TIMER benötige, die alle nötigen Bekanntmachungen in AVRStudio 
auf "ATmega16" geändert.
Die KEY's 0 und 1 sind in ihrer FUnktion erhalten geblieben
nur die LED2 leuchtet nun sofort und das Lauflicht beginnt, nach einer 
noch nicht quantifizierten Zeit, von selbst. Das Betätien der KEY2 Taste 
hat keinen Einfluss auf die Funktion der LED's.

Laut Datenblatt unterscheiden sich die relevanten Register(TIMER0) des 
ATmega16 bzw. 8515 "überhaupt" nicht. Ausnahme die Adresse des OCR0
dieses sollte meine ich in der <avr/io.h> definiert sein.

Hää? ich bin für jeden Tipp dankbar.(Schlauch)

Autor: Martin Sv (sv_martin)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin Sv schrieb:
> Nun hab ich den 8515 gegen einen ATmega 16 getauscht

Nur wer eine Frage formulieren kann, kann sie sich ach selbst 
beantworten

http://www.mikrocontroller.net/articles/AVR_Fuses

Einige Prozessoren haben eine Werkseinstellung, die zu Problemen führen 
kann. Wenn der Prozessor JTAG unterstützt (ab Mega16 aufwärts), so ist 
ab Werk die JTAG Schnittstelle eingeschaltet, was dazu führt, daß einige 
Portpins nicht wie gewohnt funktionieren (nämlich die an denen das JTAG 
Interface herausgeführt wird). In so einem Fall ist es das Beste, die 
entsprechende Fuse JTAGEN umzusetzen, um so das JTAG Interface 
abzuschalten, wenn es nicht gebraucht wird.

das war's, einen großen Dank dem Autor des o.g.Artikel

Autor: Thomas G. (old_beginner)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,

auch von mir ein Dankeschön für das Veröffentlichen dieses hilfreichen 
Codes.
Nach über 20 Jahren Pause hat mich wieder das "Mikrocomputer-Fieber" 
erfasst, damals hatte ich, allerdings nur oberflächlich, den Z80 auf 
HEX-Ebene gelangweilt, hat aber Spaß gemacht. Viele Funktionalitäten, so 
auch die Entprellung, erfolgten in HW (RS-FF).
Nun versuche ich, dem Controller (Mega8) mit C "Beine zu machen".
C ist für mich völliges Neuland, insofern sind funktionierende Module, 
wie auch diese Entprellroutine, wichtig für die ersten kleinen 
Erfolgserlebnisse.

Viele Grüße
Thomas

Autor: Hans Peter L. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,
ich habe versucht deine universelle Tastenabfrage für einen ARM Cortex 
M3 einzusetzen.
Leider bekomme ich ganz komische Effekte.
Hier der Code:
#include "inc/hw_ints.h"
#include "inc/lm3s8962.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/systick.h"
#include "driverlib/sysctl.h"
#include "driverlib/timer.h"
#include "drivers/rit128x96x4.h"


#define sei() IntMasterEnable()
#define cli() IntMasterDisable()
typedef unsigned char  u8;
typedef signed short  s16;

#define KEY_PIN  ((u8)GPIO_PORTE_DATA_R)
/*#define GPIO_PORTE_DATA_R       (*((volatile unsigned long *)0x400243FC)),
 Falls Taste 0 NICHT gedrückt, ist GPIO_PORTE_DATA_R = 00000111,
 falls gedrückt ist GPIO_PORTE_DATA_R = 00000110.
 Letztes Bit toggelt also*/

#define KEY0    0
#define KEY1    1
#define KEY2    2

#define REPEAT_MASK  (1<<KEY1^1<<KEY2)  // repeat: key1, key2
#define REPEAT_START  50          // after 500ms
#define REPEAT_NEXT  20            // every 200ms

u8 key_state;                  // debounced and inverted key state:
                          // bit = 1: key pressed
u8 key_press;                  // key press detect

u8 key_rpt;                    // key long press and repeat



#ifdef DEBUG
void
__error__(char *pcFilename, unsigned long ulLine)
{
}
#endif


void
Timer0IntHandler(void)
{
static u8 ct0, ct1, rpt;
  u8 i;
  
    TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);


  i = key_state ^ KEY_PIN;      // key changed ?
  //aktvie high, desswegen Änderung ~KEY_PIN!
  
  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;
  }

}

u8 get_key_press( u8 key_mask )
{
  cli();                    // Master Interrupts sperren
  key_mask &= key_press;            // read key(s)
  key_press ^= key_mask;             // clear key(s)

  sei();              // Master Interrupts freigeben
  return key_mask;
}


u8 get_key_rpt( u8 key_mask )
{
  cli();                    // Master Interrupts sperren
  key_mask &= key_rpt;              // read key(s)
  key_rpt ^= key_mask;               // clear key(s)
  sei();              // Master Interrupts freigeben
  return key_mask;
}


u8 get_key_short( u8 key_mask )
{
  cli();      // Master Interrupts sperren

  return get_key_press( ~key_state & key_mask );
}


u8 get_key_long( u8 key_mask )
{

  return get_key_press( get_key_rpt( key_mask ));
}


int main(void)
{



   /* CPU Clock*/
    SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                   SYSCTL_XTAL_8MHZ);

    /* Display Init*/
    RIT128x96x4Init(1000000);
    
    /* Takt an Peripherie*/
    SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
    
    /* Setze GPIOs als Eingang*/
    GPIODirModeSet(GPIO_PORTE_BASE, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2, GPIO_DIR_MODE_IN);
    
    /* Push-pull with weak pull-up, Strom auf 2mA*/
    GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2, GPIO_STRENGTH_2MA,
                     GPIO_PIN_TYPE_STD_WPU);
                     
    /* Master Interrupt einschalten*/               
    sei();
    
    /* Timer 0 - 32 Bit, Periodisch*/
    TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER);
    
    /* 10 ms Interrupt generieren*/
   TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet()/100);
   
   /* Interrup Routine festlegen*/
  TimerIntRegister(TIMER0_BASE,TIMER_A,Timer0IntHandler);
  
  /* Interrupts einschalten*/
   IntEnable(INT_TIMER0A);
   TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
   TimerEnable(TIMER0_BASE, TIMER_A);
   
   
while(1){          // main loop
     
      
   // single press
    if( get_key_short( 1<<KEY1 ))
    {
     RIT128x96x4Clear();
    RIT128x96x4StringDraw("short", 50, 40, 15);
    }
    
     
  // Repeat
    if( get_key_rpt( 1<<KEY1 ))
      {
    RIT128x96x4Clear();
    RIT128x96x4StringDraw("repeat", 50, 40, 15);
      
      }
  }
  

}

Wenn die Taste 1 gedrückt wird, erscheint auf dem Display short. Kurz 
danach erscheint dann dauerhaft repeat.
Wenn ich eine andere Taste betätige, welche ich aber nicht ab in der 
While-Schleife abfrage, erscheint auf dem Display repeat.
Hat jemand eine Ahnung woran das liegen könnte?
Deine Routine ist wirklich sehr schlank und effizient.
Der uC kann Interrupts durch Tastendrücke auslösen.
Ich bin auch gerade am überlegen ob ich das nicht mit Tasteninterrupts 
und Timer aufziehen sollte, also entprellen und tastenabfrage.

Viele Grüße

Hans

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans Peter L. schrieb:
> i = key_state ^ KEY_PIN;      // key changed ?
>   //aktvie high, desswegen Änderung ~KEY_PIN!

Und wie groß ist der Pulldown?


Peter

Autor: Hans Peter L. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich glaube 10k Ohm.
Das wird über
/* Push-pull with weak pull-up, Strom auf 2mA eingestellt.*/
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
festgelegt.

Interessant ist auch, dass nach 10 Sekunden nach dem Start bereits 
"repeat" auf dem Display ausgegeben wird, obwohl noch keine Taste 
gedrückt wurde.
Vielleicht liegt es gar nicht an dem Programm!?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans Peter L. schrieb:
> Das wird über/* Push-pull with weak pull-up, Strom auf 2mA eingestellt.*/
> GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2, 
GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
> festgelegt.

Aha, "weak pull-up" bedeutet also Pull-down?


Peter

Autor: Hans Peter L. (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Ach du sch***. Ich bin ein Eierkopf.
Danke Peter, habe es im Datenblatt (siehe Anhang) falsch abgelesen.
Deswegen habe ich es in der Routine verdreht.


Jetzt funktioniert alles, so wie es soll und das mit einer "schlanken" 
Routine

Vielen Dank!


Grüße

Autor: XMEGA (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

Hans Peter L. schrieb:
> Jetzt funktioniert alles, so wie es soll und das mit einer "schlanken"
> Routine

Ich verwende seit langem mit Erfolg Peters Tasten-Entprellung 
(Atmega/Atxmega).

Bin jetzt aber dran, mich ein wenig in die  ARM Cortex M3 (LPC1769) 
einzuarbeiten.

Ich habe das Wichtigste dieses Thread verfolgt, wie hast die 
Initialisierung der Ports jetzt realisiert?

Könntest du das nochmals in Netz stellen?

Danke XMEGA

Autor: Dominik Elbracht (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich versuche seit einigen Stunden die Funktionen auf einem Attiny2313 
zum laufen zu bekommen.
Ich habe nun quasi den Code kopiert und an den Tiny abgepasst.

Ich habe eine LED an PB0 angeschlossen. Nun, wenn ich das Programm 
starte, leuchtet die LED kurz (vermutlich bis der Timer überläuft), dann 
erlischt sie.
Bei anderen Versuchen konnte ich die LED einmal mit der Funktion 
get_key_short ausschalten, danach lies sie sich allerdings nicht wieder 
einschalten.
Ich benutze den internen Oszi bei 8MHz und habe CKDIV8-Fuse gesetzt.

Wäre toll, wenn mir jemand einen Stoß in die richtige Richtung geben 
könnte.

MfG

Autor: Steffi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
noXe schrieb im Beitrag #1015280 am 13.10.2008:
> Hallo!
> Ich versuche den das Programm von Peter Dannegger für mich anzupassen
> sodass es auf einem atmega644p läuft. Den Quellcode habe ich angehängt.
> Mein Problem ist jetzt dass das Programm nur auf KEY0 reagiert, nicht
> aber auf KEY1, bzw. es reagiert nur auf den 0ten Bit des Eingangsports.
> Habe es in AVR Studio simuliert kann aber dieses komisches Verhalten
> nicht einmal beschreiben.
> An der Verdrahtung dürfte eigentlich nichts sein. Habe alle Anschlüsse
> schon mehrmals kontrolliert.
> Kann einer bitte den Quellcode überfliegen, vielleicht habe ich ja nur
> einen dummen Fehler gemacht den ich selber nicht sehe.

Genau das selbe Problem ist auch mir aufgetreten. Das Programm reagiert 
nur auf KEY0.
Hat jemand eine Idee, wie man das beheben kann?
Im Original-Beitrag (s.o.) ist der Quellcode angehängt.

Vielen Dank...

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Steffi,

hier hatte ich mal eine Beispielprogramm geschrieben:

Beitrag "Re: 3fach Timer (einschaltverzögerung)"

Wenn Du dir bitte mal die Module in den Verzeichnissen timer und tools 
ansiehst, wird es bestimmt klarer..

Autor: Steffi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Uwe S. schrieb:
> Wenn Du dir bitte mal die Module in den Verzeichnissen timer und tools
> ansiehst, wird es bestimmt klarer..

Danke für die Hilfe, Uwe.

Im C-Code entprellen.c hab ich die "key release detect" entdeckt, welche 
du eingebaut hast.
Könnte das auch mir bei meinem Problem helfen?

Bevor ich etwas ausprobier und meinen C-Code umgestalte, würde ich gerne 
wissen, dass ich nicht komplett auf dem Holzweg bin.

Vielen Dank und Gruß
Steffi

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

was ist das Problem ?

Ich denke bevor man nicht den gesamten CODE versteht, sollte man 
versuchen Stück für Stück dem Verständnis näher zu kommen und immer nur 
kleine Änderungen an Programmen machen.
Nur so lerne ich etwas..

Also nun ran an den Speck.
uint8_t get_key_release( uint8_t key_mask );
wurde irgendwann mal im Thread diskutiert und veröffentlicht.

Beitrag "Re: Universelle Tastenabfrage"

Als Ergänzung noch dieser Link: 
Beitrag "Re: Universelle Tastenabfrage"


Noch eine Tipp zum Programm:

Beitrag "Re: Universelle Tastenabfrage"
#define ALL_KEYS        (1<<KEY0)

Es wird auch nur ein Bit als Eingang definiert !

Autor: Steffi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Uwe S. schrieb:
> Also nun ran an den Speck

Bin schon dabei.

Leider ist so ein C-Code zur Taster-Entprellung nicht so trivial,
besonders für Anfänger wie mich.

Habe schon eine Tastenentprellung von Peter Dannegger auf mein Programm 
angepasst. Leider tritt dann das Problem auf, dass das Programm nur auf 
den ersten Taster reagiert und den zweiten "ignoriert".

Ein Tipp, wie ich hier weiter vorgehen könnte, würde mir sehr helfen.

Vielen Dank

Steffi

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter und andere lesen auch hier mit, also hänge doch deine komplettes 
Programm bitte hier an !

Dann sehen wir alle schneller wo es hängt.

Autor: Steffi (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Uwe S. schrieb:
> hänge doch deine komplettes Programm bitte hier an !
>
> Dann sehen wir alle schneller wo es hängt.

Danke für die Unterstützung!

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Steffi,

schon mal das Programm übersetzt und wenn ja, was sind die 
Fehlermeldungen ?

Wie Arbeitest Du mit dem avr-gcc - ich meine mit welcher Umgebung ?

Ich verwende klassisch nur ein Makefile, make in einer bash-shell.

Autor: Steffi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Weder Fehlermeldung, noch warnings.

Ich verwende das AVR Studio 4.

Konntest du irgendwelche Ungereimtheiten im C-Code finden?

Beitrag #2298913 wurde vom Autor gelöscht.
Autor: Helmut Brammer (helmut70)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Steffi schrieb:

> Konntest du irgendwelche Ungereimtheiten im C-Code finden?

Dein C-Code sieht recht ordentlich aus.
Natürlich ist er umfangreicher, als nötig, aber sicher ist sicher :)

Für deine Taster benutzt du PINC1 und PINC2, aber nur der PINC1 
"funktioniert".

Versuch doch einfach mal einen anderen PIN zu nehmen anstatt PINC2.
Vielleicht hilft es ja...

Gruß Helmut

Autor: Steffi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Oh, sieh an.
Auf einem anderen PIN funktioniert der Taster einwandfrei!

Ich weiß zwar noch nicht genau wieso, aber das werd ich schon noch 
herausfinden :)

Danke, Helmut

Autor: Tilman (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Heyho,

für active high muss noch eine zweite Zeile geändert werden, sonst 
liefert get_key_rpt und damit auch get_key_long für jede nicht gedrückte 
Taste das Signal, dass sie gedrückt sei.

Ändere
key_rpt |= key_state & REPEAT_MASK;
in
key_rpt = ~key_rpt & ~(key_state & REPEAT_MASK);
oder (vielleicht einfacher zu erkennen, was gemacht wurde)
key_rpt = ~(key_rpt | (key_state & REPEAT_MASK));

Diese Zeilen invertieren einfach key_rpt.

Tschau,
Procyon

Autor: Flozilla (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter und Co,

ich versuche gerade die Entrpellung für einen Attiny25 zu verwenden. 
Irgendwie bekomme ich es im Moment nicht gebacken.

Trotzdem schon mal danke an Peter für diese Routine :)
/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys        */
/*      Sampling 4 Times        */
/*      With Repeat Function        */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      danni@specs.de                                  */
/*                                                                      */
/************************************************************************/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>

typedef unsigned char  u8;
typedef signed short  s16;

#define  XTAL    1e6    // 1MHz

#define KEY_DDR    DDRB
#define KEY_PIN    PINB
#define KEY_PORT  PORTB
#define KEY0    4

#define LED_DDR    DDRB
#define LED_PORT  PORTB
#define LED0    0
#define LED1    1
#define LED2  2


#define REPEAT_MASK  (1<<KEY0)  // repeat: key1
#define REPEAT_START  50    // after 500ms
#define REPEAT_NEXT  20    // every 200ms


u8 key_state;        // debounced and inverted key state:
          // bit = 1: key pressed
u8 key_press;        // key press detect

u8 key_rpt;        // key long press and repeat


SIGNAL (SIG_OVERFLOW0)      // every 10ms
{
  static u8 ct0, ct1, rpt;
  u8 i;

  TCNT1 = (u8)(s16)-(XTAL / 1024 * 10e-3 + 0.5);  // preload for 10ms

  i = key_state ^ ~KEY_PIN;    // 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;
  }
}


u8 get_key_press( u8 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;
}


u8 get_key_rpt( u8 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;
}


u8 get_key_short( u8 key_mask )
{
  cli();      // read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
}


u8 get_key_long( u8 key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}


int main( void )
{
  TCCR1 = 1<<CS02^1<<CS00;      // divide by 1024
  TIMSK = (1<<TOIE1);        // enable timer interrupt
  //PB4 als Eingang konfigurieren
  KEY_DDR &= ~(1<<KEY0);
  //Pullup aktivieren bei PB4
  KEY_PORT = (1<<KEY0);
  //Ausgänge konfigurieren
  LED_DDR |= (1<<LED0)|(1<<LED1)|(1<<LED2);
  sei();

  for(;;){          // main loop
      // single press

    if( get_key_press( 1<<KEY0 ))
      LED_PORT ^= 1<<LED0;

      // release after short press: task 1
      // long press: task 2

    if( get_key_short( 1<<KEY0 ))
      LED_PORT ^= 1<<LED1;

    if( get_key_long( 1<<KEY0 ))
      LED_PORT ^= 1<<LED2;

      // single press and repeat

    /*if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
      u8 i = LED_PORT;

      i = (i & 0x07) | ((i << 1) & 0xF0);
      if( i < 0xF0 )
        i |= 0x08;
      LED_PORT = i;      
    }*/
  }
}

Weiß zufällig jemand was ich falsch mache?

Gruß Flo

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

schau dir bitte die angepassten Routinen von PeDa in diesem Beitrag an:

Beitrag "Re: 3fach Timer (einschaltverzögerung)"

http://www.mikrocontroller.net/attachment/107805/c...


Was dir sofort auffallen sollte beiden Dateien unter tools:
volatile uint8_t key_state;

Es wurden also noch einige wichtige Änderungen hier im Thread gemacht, 
die dann eingeflossen sind.

Also lese bitte alles von Oben nach.

Autor: Pascal Schulz (pascal900198)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin alle zusammen! Erstmal frohe Weihnachten :)

Ich versuche gerade zu verstehen, wie die Methode get_key_long() 
funktoniert.
Ich bin mir nicht sicher, ob dies hier schon einmal erklärt worden ist. 
Ich habe mich bemüht den ganzen Thread durchzugucken, habe aber nichts 
gefunden.

So, nun zur eigentlichen Frage. Zuerst wird ja get_key_rpt() aufgerufen 
und das wird nur eins, wenn die Taste min. 500ms gedrückt wurde. Dann 
kommt die Methode get_key_press() ins Spiel. Wenn die Taste noch nicht 
500ms gedrückt wurde, wird ihr ja die ganze Zeit als Parameter 0x00 
übergeben und es kommt immer 0x00 zurück. Nach 500ms wird ihr dann eben 
die 1 an der jeweiligen Position übergeben. Aber nach 500ms wurde das 
Bit in key_press doch schon längst gelöscht, weil das ja sofort beim 
Timeroverflow nach dem setzen wieder gelöscht wird. Also müsste 
get_key_press() dann doch immer eine 0 liefern?
Aber sie gibt ja eine 1 zurück, warum funktiniert das?

Danke schon mal und noch ein fröhliches Weihnachtsfest.

Gruß
Pascal

Autor: Vincent Hamp (vinci)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Tilman schrieb:
> Heyho,
>
> für active high muss noch eine zweite Zeile geändert werden, sonst
> liefert get_key_rpt und damit auch get_key_long für jede nicht gedrückte
> Taste das Signal, dass sie gedrückt sei.
>
> Änderekey_rpt |= key_state & REPEAT_MASK;
> inkey_rpt = ~key_rpt & ~(key_state & REPEAT_MASK);
> oder (vielleicht einfacher zu erkennen, was gemacht wurde)key_rpt = ~(key_rpt | 
(key_state & REPEAT_MASK));
>
> Diese Zeilen invertieren einfach key_rpt.
>
> Tschau,
> Procyon


Servus

Verwende Hr Danneggers Code nun schon eine Weile und bin äußerst 
zufrieden damit. Hab ihn nun auch das erste mal mit active high Tastern 
in Verbindung und mir hierzu die Foreneinträge angesehen.

Meiner Meinung nach muss für active high Schalter lediglich das KEY_PIN 
Makro invertiert werden (siehe 
Beitrag "Re: Universelle Tastenabfrage"), der Rest bleibt 
exakt gleich! Schließlich wird ja der Port auch nur an dieser Stelle 
"eingelesen". Die restliche Logik ändert sich ja nicht.

Da ich eine faule Natur bin und die Logik nur kurz überflogen hab, hab 
ich das ganze einem Praxistest unterzogen und tatsächlich, key_rpt 
funktioniert in der Standardversion einwandfrei.

Kein Grund also, key_rpt in der ISR umzuschreiben? (geschweige denn die 
long_... Funktion.


lg
Vincent


ps: Ich ändere den Artikel erst, sofern dies jemand bestätigt hat, da 
ich Teile des Codes stark modifiziert hab. (mehrere Ports, Pins 
verschiedener Ports, usw.) Ev. lieg ich ja doch falsch.

Autor: Felix (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für den Super Code!, leider funktioniert bei mir die get_key_long 
funktion nicht (es togglet ausschließlich LED0 mit KEY1 (beim 
loslassen)). Ich arbeite mit einem ATTiny 2313 auf dem Pollinboard, 
IDE-Kabel und dem Adapter 
(http://www.pollin.de/shop/dt/MjQ5OTgxOTk-/Bausaetz..., 
alle Jumper gezogen).

Ich weiß auch nicht ob der Takt richtig eingestellt habe, eigentlich hab 
ich ja nen externen 8 MHz quarz der standardmäßig akiviert sein müsste, 
oder? Nur dann Toggelt es bei KEY2 zu langsam.
/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      danni@specs.de                                  */
/*                                                                      */
/************************************************************************/
 
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
 
#define F_CPU 1000000
 
#ifndef F_CPU
#define F_CPU           1000000                   // processor clock frequency
#warning kein F_CPU definiert
#endif
 
#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            4
#define KEY1            2
#define KEY2            3
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)
 
#define REPEAT_MASK     ( 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms
 
#define LED_DDR         DDRD
#define LED_PORT        PORTD
#define LED0            1
#define LED1            2
#define LED2            5
#define ALL_LEDS        (1<<LED0 | 1<<LED1 | 1<<LED2)
 
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 ^ ~KEY_PIN;                       // 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;
}
 
///////////////////////////////////////////////////////////////////
//
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 )
{
  LED_PORT |= ALL_LEDS;
  LED_DDR  |= ALL_LEDS;                     
 
  // Configure debouncing routines
  KEY_DDR &= ~ALL_KEYS;                // configure key port for input
  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors
 
  TCCR0B = (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<<KEY1 ))
      LED_PORT ^= 1<<LED0;
 
    if( get_key_long( 1<<KEY1 ))
      LED_PORT ^= 1<<LED2;
 
    // single press and repeat
 
    if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
   LED_PORT ^= 1<<LED0;
    }
  }
}


Nebenbei ist mir noch aufgefallen, dass PD0 und 5 immer high und PD6 
immer low sind, aber ich denke da hab ich was beim löten versaut, da 
mach im mich jetzt mal auf die suche :)

Autor: Felix (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Felix schrieb:
> Nebenbei ist mir noch aufgefallen, dass PD0 und 5 immer high und PD6
> immer low sind, aber ich denke da hab ich was beim löten versaut, da
> mach im mich jetzt mal auf die suche :)

den fehler hab ich schonmal gefunden, Am IDE-Kabel sind die GND 
leitungen verbunden :( ätzend

Autor: 3RR0R (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
In Anlehnung vom Code des Herrn Peter Dannegger, habe ich meine eigene 
"Tasten Entprellung" mit "0-1 Flanken" dedection geschrieben, da ich den 
Code vom Herrn Peter Danneger nicht so ganz verstanden habe.
Aus diesem Grunde wollte ich die "Profis" hier mal fragen ob "mein code" 
blödsin ist oder nicht.
Die Beschreibung der Funktionsweise ist in der Datei vorhanden

Danke für eure Mühe und Antworten

3RR0R

Beitrag #2751740 wurde von einem Moderator gelöscht.
Autor: Patrick (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo und schönen guten Abend,
ich nutze auch den Code von Peter. Hab aber ein Problem, da ich zwei 
Tasten von DDRB und DDRC nutzen muss. Geht leider nicht anders.

#define DDR_Key    DDRC  DDRB

Also wie muss ich das richtig definieren?


Kann mir da jemand auf die Sprunge helfen?

Vielen Dank schon mal im Voraus.

Gruß Patrick

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

dann musst Du die gesamte Routine zwei mal verwenden und die Funktion 
des Codes entsprechend (Namen) anpassen.

Also auch in der ISR die beiden Ports nach einander einlesen und 
entprellen.

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du kannst alle Datentypen auf uint16_t erweitern und die oberen 8 Bits 
für den einen und die unteren 8 für den anderen Port verwenden. In der 
ISR musst du dann halt noch die beiden Ports einlesen und an die 
entsprechenden Positionen schieben.

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Forum,

ich möchte den Code gerne für eine konfigurierbare Anzahl Ports 
erweitern.
Dabei habe ich aber ein paar Schwierigkeiten.

Meine Idee ist, die Varbiablen mit dem Keystatus als Array zu erweitern.
Aus "volatile uint8_t key_state" wird "volatile uint8_t key_state[x]"
Wobei x der Anzahl der Ports entspricht.
Das kann ich auch in der ISR als Schleife gut durchlaufen.

Jetzt brauche ich aber für jeden Port ja auch die Angabe, welcher Port 
es nun genau ist.
Also muss ich für jeden Port noch soetwas haben:
#define KEY_PORT        PORTG
#define KEY_PIN         PING
Aber dann müsste ich ständig unterscheiden und habe doch wieder ganz 
viel Code doppelt.
Dann kommen dazu noch mehr Defines, die zu noch mehr Unterscheidungen 
führen würden. Für jeden Port:
#define USE_KEY_RELEASE
#define USE_KEY_REPEAT
#define ACTIVE_STATE (active high or low)
Möchte man es noch flexibler, müsste man sogar jeden Portpin einzeln als 
active high oder low definieren können.

Ein weiterer Punkt ist dann, dass ich jeder Funktion zur Tastenabfrage 
(get_key_press() etc.) dann auch noch den zugehörigen Port bzw. x (von 
oben) übergeben müsste. Das macht die Nutzung im Programm umständlich 
und fehleranfällig.

Wie geht man an sowas ran und setzt das vernünftig um?
Oder ist das viel zu aufwändig und man kopiert besser allen Code für 
jeden Port und vergibt neue Namen?
Ich benötige beispielsweise 4 Ports.

Vincent Hamp schrieb:
> ps: Ich ändere den Artikel erst, sofern dies jemand bestätigt hat, da
> ich Teile des Codes stark modifiziert hab. (mehrere Ports, Pins
> verschiedener Ports, usw.) Ev. lieg ich ja doch falsch.

Dein Code Vincent würde mich sehr interessieren!

Danke und Gruß
Peter

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Schade, keine Hinweise zur konzeptionellen Umsetzung...
Da ich jetzt mit 8 Tasten auf 3 verschiedenen Ports auskomme, habe ich 
es in Anlehnung an
Beitrag "Re: Entprellung mit Dannegger-Code auf unterschiedlichen Ports"
gelöst. Allerdings mit "active low" und "active high" Tasten gemischt.

Einzige Änderung im Code:
local = key_state ^ KEYS_PIN_MIXED;            // key changed?
mit folgenden Defines:
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define KEY3            3
#define KEY4            4
#define KEY5            5
#define KEY6            6
#define KEY7            7
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2 | 1<<KEY3 | 1<<KEY4 | 1<<KEY5 | 1<<KEY6 | 1<<KEY7)

//set according hardware pins
#define KEY0_PIN     (PING&(1<<PG0))       //PG0 -> key0
#define KEY1_PIN     (PINC&(1<<PC1))       //PC1 -> key1 
#define KEY2_PIN    ((PINC&(1<<PC0))<<2)   //PC0 -> key2 
#define KEY3_PIN    ((PINC&(1<<PC7))>>4)   //PC7 -> key3
#define KEY4_PIN     (PINE&(1<<PE4))       //PE4 -> key4
#define KEY5_PIN     (PINE&(1<<PE5))       //PE5 -> key5
#define KEY6_PIN     (PINE&(1<<PE6))       //PE6 -> key6
#define KEY7_PIN     (PINE&(1<<PE7))       //PE7 -> key7
#define KEYS_ACTIVE_HIGH        (KEY4_PIN | KEY5_PIN | KEY6_PIN | KEY7_PIN)
#define KEYS_ACTIVE_HIGH_MASK   ((1<<KEY4)|(1<<KEY5)|(1<<KEY6)|(1<<KEY7))   //must set bits according to KEYS_ACTIVE_HIGH
#define KEYS_ACTIVE_LOW         (KEY0_PIN | KEY1_PIN | KEY2_PIN | KEY3_PIN)
#define KEYS_PIN_MIXED          ( KEYS_ACTIVE_HIGH | (uint8_t)~(KEYS_ACTIVE_LOW | KEYS_ACTIVE_HIGH_MASK) )
Die KEYS_ACTIVE_HIGH_MASK ist wichtig, da sonst durch die Invertierung 
der "active low" Taster die "active high" Taster gesetzt werden.

In den Defines oben ist die Benennung mit KEYx übersichtlicher.
Dann kann man sich für die Tasten immer noch sprechende Defines anlegen:
#define ButtonOK  KEY0
...

Vielleicht hilft das noch jemandem weiter.

Gruß
Peter

Autor: Michael K. (kichi) (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Naja wie bereits geschrieben hättest du die Typen erweitern können. So 
kannst du mit uint32 bspw. 32 Tasten entprellen, sprich 4 Ports beim 
AVR8.

Oder du machst Arrays aus allen Variablen und baust dir bspw. eine 
Funktion der du die Eingangsdaten und einen Index mitgibst und die dir 
dann speziell diese Indices entprellt. In der ISR rufst du dann diese 
Funktion entsprechend (oft) auf:
#define NO_OF_ELEM 2

u8 key_state[NO_OF_ELEM];
u8 key_press[NO_OF_ELEM];
u8 key_rpt[NO_OF_ELEM];

void debounce (u8 input, u8 index)
{
  static u8 ct0[NO_OF_ELEM], ct1[NO_OF_ELEM], rpt[NO_OF_ELEM];
  u8 i;

  TCNT0 = (u8)(s16)-(XTAL / 1024 * 10e-3 + 0.5);

  i = key_state[index] ^ ~input;
  ct0[index] = ~( ct0[index] & i );
  ct1[index] = ct0[index] ^ (ct1[index] & i);
  i &= ct0[index] & ct1[index];
  key_state[index] ^= i;
  key_press[index] |= key_state[index] & i;

  if( (key_state[index] & REPEAT_MASK) == 0 
     rpt[index] = REPEAT_START;
  if( --rpt[index] == 0 ){
    rpt[index] = REPEAT_NEXT;
    key_rpt[index] |= key_state[index] & REPEAT_MASK;
  }
}

SIGNAL (SIG_OVERFLOW0)
{
   debounce(PINA, 0);
   debounce(PINB, 1);
   //...
}
<- auf die schnelle aus dem Code aus dem ersten Beispiel gebastelt ohne 
es zu testen.

Für REPEAT_MASK, REPEAT_START & REPEAT_NEXT müsste man sich noch was 
überlegen falls die abweichen (sollen).

Die anderen Funktionen müssen dann natürlich auch Indices unterstützen.

Vorteil von letzterer Lösung wäre, dass du mit unterschiedlichen 
Intervallen entprellen kannst.

Autor: Thomas H (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karsten K. schrieb:
> Moin Moin!
> Ich möchte die get_key_common() Funktion nutzen um durch langes drücken
> zweier Tasten in den "Programmier-mode" zu gelangen.
> Die Funktion reagiert aber auch schon auf kurzen Tastendruck. Wie kann
> ich die Funktion erweitern/verändern, sodaß nur auf langes drücken
> zweier Tasten reagiert wird?
>
> 10000000 * 10^12 Dank für eure Hilfe
>
> Karsten

Das würde mich auch interessieren. Gibt es da eine Möglichkeit?

Gruß,
Thomas

Beitrag #2872618 wurde von einem Moderator gelöscht.
Beitrag #2872627 wurde von einem Moderator gelöscht.
Autor: ratlosER (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das war gestern wohl etwas zu spät !! Bitte meine letzten beiden 
postings löschen !!!! Habe es heute morgen noch einmal aufgemalt und die 
ISR jetzt verstanden.

Sorry !

Autor: Jürgen F.K. (snipor)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe folgendes Problem. Die Erkennung von kurzem und langem 
Tastendruck funktioniert nicht immer.
Mein Testaufbau besteht aus einem Attiny 2313 auf einem STK500. Ich 
verwende die internen 8MHz und den 8er Teiler.

Folgendes Szenario:
Ich drücke die Taste kurz, ein kurzer Tastendruck wird erkannt.
Sofort drücke ich die Taste nochmal, ein langer Tastendruck wird 
erkannt.

Dieses Verhalten tritt des öfteren auf.

Wenn ich also die Taste dauernd kurz drücke wird meistens ein kurzer 
Druck erkannt, jedoch manchmal auch einer langer Tastendruck.

Ich habe auch REPEAT_START mittlerweile auf 2s, jedoch wird der lange 
Druck schon viel früher erkannt.
Nach meinem empfinden ist die Erkennungszeit für einen langen 
Tastendruck nicht immer gleich.

Was könnte da falsch sein?

Stimmt da evtl. was mit dem Timerüberlauf nicht?

Danke

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was hängt an PINA.2 ?

Änder mal die Zeile in:
#define REPEAT_MASK     (1<<KEY1)       // repeat: key1

Peter

Autor: Jürgen F.K. (snipor)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,

danke für Deine Antwort.

An PINA.2 hängt der Reset des Attiny. Das dürfte aber doch keinen 
Einfluss haben, oder?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jürgen F. schrieb:
> An PINA.2 hängt der Reset des Attiny. Das dürfte aber doch keinen
> Einfluss haben, oder?

Doch.
Die Repeat-Maske ist nicht einfach so da, weil ich Codezeilen schinden 
wollte.
Sie hat auch eine Funktion:
Sobald ein Pin in der Repeat-Maske betätigt (low) ist, fängt die 
Repeat-Zeit an zu zählen.

Die Repeat-Maske darf daher nur die Pins beinhalten, die auch repeatet 
werden sollen!


Peter

Autor: Jürgen F.K. (snipor)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,

aber der Reset ist doch in der Regel auf High, solange er nicht betätigt 
wurde, also dürfte er doch das System nicht beeinflussen?

Oder habe ich da irgendwo einen Denkfehler?

Aber natürlich hast Du recht, dass der Resetpin nichts in der Maske 
verloren hat.
Es funktioniert auch mit der von Dir empfohlenen Änderung.

Danke

Gruß Jürgen

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jürgen F. schrieb:
> aber der Reset ist doch in der Regel auf High, solange er nicht betätigt
> wurde, also dürfte er doch das System nicht beeinflussen?

Nö.
Das Datenblatt schweigt sich dazu leider aus. Eine genaue 
Portbeschreibung ist nur für PORT B und D vorhanden. PORT A wurde 
vergessen.

Nimmt man mal das Datenblatt des ATtiny25 und den Pin PB5, dann steht in
Table 10-4. Overriding Signals for Alternate Functions in PB[5:3]
daß der Eingang durch /RSTDISBL abgeschaltet wird und somit 0 zurück 
gelesen wird.

Und vermutlich verhält sich PINA2 des Attiny2313 auch so.


Peter

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich hätte dazu auch noch eine Frage.
Wann wird ein Tastendruck als kurz und wann als lang erkannt.

Ich habe es so verstanden, dass wenn die Repeat-Zeit überschritten wurde 
(mind. einmal), so wird lang erkannt. Kurz dann, wenn noch kein Repeat 
statt gefunden hat.

Ist das so richtig?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
REPEAT_START ist die Zeitschwelle für kurz/lang.

Peter

Autor: Daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
danke für die sehr schöne Entprellung. Ich spiele gerade mit einem 
tiny13 herum und die Erkennung der langen und kurzen Tastendrücke 
funktioniert gut.


Mein Problem ist, wenn ich das TCCR0A für PWM konfiguriere funktioniert 
das lang kurz erkennen nicht mehr und wenn ich CTC einstelle dann klappt 
das PWM nicht mehr....
Ist es irgendwie möglich die LEDs mit PWM zu dimmen anstatt nur ein und 
auszuschalten im tiny13?

Autor: Daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann ich einfach die iSR in new funktioniert umwandeln und in der main 
loop aufrufen?

Autor: Daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann ich die ISR einfach in eine Funktion umwandeln und in der main loop 
aufrufen?

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Der Overflowinterrupt funktioniert auch im PWM-Modus.
Du mußt nur noch eine Variable zählen, bis ~10ms rum sind.

Oder nimm den ADC-Interrupt.
Oder nimm den Watchdoginterrupt.
Oder ein 10ms Delay in der Mainloop.

Autor: Daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wollte mich nur mal rückmelden, ich habe es nun in den Watchdoginterrupt 
eingebaut und den lasse ich alle 16mS aufrufen.

Habe die repeat_start einfach bisschen reduziert damit die langen 
Tastendrücke nicht so lang sind und nun kann ich superkomfortabel und 
Kugelsicher mit einem Taster auf und abdimmen.

Vielen Dank

Autor: Adrian E. (ahsd)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Ist es mit der C_TAST.C Methode möglich, mehr als 8 Taster abzufragen?

Ich stehe am Anfang eines Projektes, bei dem die Bedienoberfläche etwa 
13 Taster hätte.

: Bearbeitet durch User
Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Adrian,

wenn Du dir die 8 Bit Portzugriffe auf z.B. zwei ports Erweiterst.

Wir habe schon einen 8 Port (8Bit) Version realisiert.

Autor: Jens (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Adrian,

wenn es mehr braucht kannst du das auch als Matrix machen, hab ich 
weiter oben schon mal eine Anpassung gepostet.

vg jens

Autor: Adrian E. (ahsd)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jens schrieb:
> Hallo Adrian,
>
> wenn es mehr braucht kannst du das auch als Matrix machen, hab ich
> weiter oben schon mal eine Anpassung gepostet.
>
> vg jens

Hallo Jens,

ich konnte deine .zip Datei nicht runterladen, vielleicht ist der 
Beitrag schon zu alt?


Mal kurz von meinem Vorhaben mit 13 Tastern abgesehen:
Ich bin gerade immer noch am Schwitzen um die normale Version zum Laufen 
zu bekommen / ansatzweise zu verstehen. Ich glaube ich habe gerade 
gecheckt, dass vorausgesetzt ist, dass man nicht am gleichen Port Taster 
und LEDs verwendet, oder? Das heißt mit einem Attiny13 ist der Code 
nicht ohne weiteres möglich, aber an einem 2313? (Der hat PA, PB, PD.)

Liebe Grüße,
Adrian.

Beitrag #3516588 wurde vom Autor gelöscht.
Autor: Adrian E. (ahsd)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Oder um die Frage nochmal etwas präziser zu formnulieren: Auf welchen 
AVR Modellen lässt sich dieser Code ausführen?

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Adrian,

das ist nur vom Compiler abhängig, in wieweit der C für dein Zielsystem 
unterstützt!

Und dem Lesen des Datenblattes für deinen µC um
a) die Ports richtig ansprechen zu können und
b) einen Timer mit ca 10ms Interruptzykluszeit muss man auch noch 
aufsetzen können.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Adrian E. schrieb:
> Ich glaube ich habe gerade
> gecheckt, dass vorausgesetzt ist, dass man nicht am gleichen Port Taster
> und LEDs verwendet,

Nein.
Die Routine liest ja nur ein und gibt nichts auf Pins aus.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Adrian E. schrieb:
> bei dem die Bedienoberfläche etwa
> 13 Taster hätte.

Hier eine Variante mit Leitungen sparen:
Beitrag "Tastenmatrix auslesen über nur 2 Leitungen"

Autor: Jenny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie wird die Zeit für das langdrücken festgelegt?

Autor: Adrian E. (ahsd)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Hier eine Variante mit Leitungen sparen:
> Beitrag "Tastenmatrix auslesen über nur 2 Leitungen"

Super! Danke für den Tipp, Peter.
Ich werde trotzdem erstmal versuchen es mit weniger Tasten anzugehen.

Uwe S. schrieb:
> b) einen Timer mit ca 10ms Interruptzykluszeit muss man auch noch
> aufsetzen können.

Wie schon erwähnt bin ich Anfänger und mir ist daher nicht klar, wie man 
das macht. Ich bitte um etwas Nachsicht :)Ich lerne gerade etwas 
parallel C und AVR. Könnt ihr mir auf die Sprünge helfen, wie ich das 
auf einem Attiny2313 zum laufen bekomme?

LG,
Adrian.

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo  Adrian,

ich hatte das auch ganz ohne Wertung geschrieben.

Das Datenblatt zu deinem µC gibt es frische immer bei Atmel.com

und als Wissenbasis kann man auf diese Artikel verweisen:

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

Damit kannst du bei weiteren Fragen einen neuen Thread eröffnen.

Immer nur einen pro Frage, sonst fallen die anderen über Dich her.

Autor: Jörg Mauer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
ich habe ein Problem mit der Routine. Das lange und das kurze drücken 
funktioniert, nur verstehe ich nicht wie die anderen Funktionen genutzt 
werden. Konkret möchte ich kurze, lange und sehr lange Tastendrücke 
unterscheiden.
//short und long werden zuverlässig erkannt aber die beiden unteren machen nichts
  if( get_key_short( 1<<KEY0 )){LED_PORT ^= 1<<LED0;}
  
  if(get_key_long( 1<<KEY0 )) { LED_PORT ^= 1<<LED3;}               
                  
  if( get_key_long_r( 1<<KEY0 )) { LED_PORT ^= 1<<LED0;}

  if( get_key_rpt_l( 1<<KEY0 )) {LED_PORT ^= 1<<LED0;}


Ich bin um jeden hilfreichen Rat dankbar.

Gruß Jörg

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Jörg Mauer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
getkeylong auskommentieren und dann geht es?

Autor: Seppel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> @Philipp
>
> Versuchs mal hiermit:
> u8 get_key_long2( u8 key_mask )
> {
>   return get_key_press( get_key_rpt( key_press^key_mask ));
> }
>
> u8 get_key_long_rpt( u8 key_mask )
> {
>   return get_key_rpt( ~key_press^key_mask );
> }
get_key_short: ein/aus
get_key_long2: Dimmrichtung wechseln
get_key_long_rpt: dimmem.
 Peter

Das funktioniert nicht so ganz, beim loslassen nach langem drücken wird 
einmal getkeyshort aufgerufen, getkeylong2 wird niemals aufgerufen...

Autor: Marco (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja das ist mehrfach im Thread erwähnt, das auf und abdimmen mit einer 
Taste funktioniert nicht...hat der Peda wohl irgendwas vergessen zu 
erwähnen

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Seppel schrieb:
> Das funktioniert nicht so ganz


Richtig ist:
Beitrag "Re: Universelle Tastenabfrage"

Autor: Adrian E. (ahsd)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich bin immer noch dabei mit der Tastenabfrage warm zu werden. Ich 
brauche im Moment nur eine einfache Tastenabfrage, ohne länger Drücken 
usw. Könnt ihr mir erklären, warum bei mir folgende Zeile alleine nicht 
funktioniert?
if( get_key_press( 1<<KEY0 ))
      LED_PORT ^= 1<<LED0;

Wenn auch folgende Zeile aufgerufen wird, funktioniert es:
if( get_key_short( 1<<KEY1 ))
      LED_PORT ^= 1<<LED1;

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ändern in:
volatile u8 key_press;        // key press detect

Autor: Adrian E. (ahsd)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> ändern in:
> volatile u8 key_press;        // key press detect

Danke Peter!!! Die Rettung :)

Autor: Ich (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Da mit der "Komfort-Routine" aus 
http://www.mikrocontroller.net/articles/Entprellun... 
nach Start bzw. Reset sofort ein kurzer Tastendruck erkannt wurde, habe 
ich nochmal den älteren Thread durchforstet und bin zum Thema 
Initialisierung auf diese Posts gestoßen:

Beitrag "Re: Tasten entprellen - Bulletproof"
Beitrag "Re: Tasten entprellen - Bulletproof"
Peter Dannegger schrieb im Beitrag #989432:
> Du hast natürlich recht, CT0 und CT1 müßten mit 0xFF initialisiert
> werden, damit erst nach 4 Durchläufen die Übernahme erfolgt.
>
> Noch besser wäre es, auch key_state mit 0xFF zu initialisieren. Dann
> werden bereits beim Einschalten gedrückte Tasten ignoriert.

Gruß in den Wedding!

Autor: Thomas Beck (ewi)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe diese geniale Routine zum Tastenentprellen in einer älteren 
Version das erste Mal im Source Code vom OBD2-Analyser NG aus Elektor 
09/2009 gefunden. Dort war sie leider völlig kommentarlos drin und so 
habe ich erst viel später hier den wahren Autor und die Erklärung der 
Funktionsweise entdeckt. Vielen Dank dafür vor allem an Peter Dannegger 
und all die anderen Leute, die Verbesserungen dafür angeregt haben :-)

Inzwischen habe ich mich durch den Source Code des Analysers gewühlt und 
auf der Elektor Labs Seite auch ein paar Firmware Updates dafür 
veröffentlicht. Dabei hab ich mir die Tastenroutine genauer angeschaut 
und zumindest für meinen Fall (AT90CAN128 mit avr-gcc  v4.8.0 und 
Optimierung -s) noch eine Möglichkeit zur Laufzeitverbesserung gefunden 
(siehe Anhang).
Wenn man die volatile Variable keyState zu Beginn der Interruptroutine 
in eine lokale Variable (= sehr wahrscheinlich ein Register) umkopiert, 
dann nur mit der Kopie arbeitet und erst am Ende der Interruptroutine 
wieder in die volatile Variable zurückspeichert, lassen sich in meinem 
Fall zwischen 4-7 Taktzyklen Laufzeit einsparen.
Warum das so ist, steht hier:
http://www.mikrocontroller.net/articles/AVR-GCC-Tu...
und im englischen Kommentar auch in der angehängten Datei.

Autor: Thomas Beck (ewi)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Nachtrag zu meinem vorigen Beitrag.

Wenn man das Zurückspeichern der lokalen Variable in die volatile 
Variable nicht am Ende der ISR macht, sondern sobald nicht mehr 
schreibend auf die lokale Variable zugegriffen wird (siehe Anhang), 
ermöglicht man dem Compiler/Optimizer ein weiteres MOV (1 Zyklus) 
einzusparen. So dass man mit dieser Änderung dann in meinem Fall 
zwischen 5 bis 8 Taktzyklen Laufzeit einspart.

Soweit die gute Nachricht. Wer aber im Gegensatz zu mir in der ISR nur 
das Tastenentprellen und nichts anderes mehr macht, spart nur 1-4 
Zyklen. Warum? Für die lokale Variable muss ein freies Register zur 
Verfügung stehen. Aufgrund anderer Aktionen in der ISR ist das bei mir 
der Fall. Wie ich inzwischen getestet habe, ist das in der 
Originalroutine nicht der Fall. D.h., dort ist im Prolog der ISR ein 
zusätzliches PUSH (2 Zyklen) nötig, um den aktuellen Registerinhalt für 
das benötigte Register auf den Stack zu speichern. Im Epilog ist dann 
ein zusätzliches POP (2 Zyklen) nötig, um das Register wieder mit dem 
alten Registerinhalt zu laden. Damit ist der Großteil der 
Laufzeitersparnis leider wieder dahin.

Dann noch eine ergänzende Angabe zur möglichen Ersparnis. Wenn ich 
richtig gezählt habe, benötigt die Originalroutine beim AT90CAN128 mit 
avr-gcc v4.8.0 und Optimierung -Os etwa 85-88 Taktzyklen (Minimum 4 
Zyklen zum Einsprung in die ISR + 14 Zyklen Prolog + 50-53 Zyklen 
eigentliche ISR + 17 Zyklen Epilog). Eine Ersparnis von 1-4 Zyklen 
Laufzeit sind also immer weniger als 5%. In meinem Fall sind es maximal 
auch nur wenig mehr als 5%.
Bei anderen Optimierungsstufen ergeben sich vermutlich noch andere 
Ergebnisse. Das muss jeder für sich selbst testen, ob es in seinem 
Anwendungsfall etwas bringt.

Autor: Horst (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo und Danke Peter für die lehrreiche Routine.

Um einen langen Tastendruck zu erkennen muss der jewilige Input ja in 
der REPEAT_MASK eingetragen werden. Sobald jetzt eine Taste davon 
gedrückt wird beginnt rpt mit REPEAT_START abzulaufen (wird die Taste 
wieder losgelassen wird immer mit REPEAT_START rückgesetzt), geschieht 
das wird die jeweilite Taste in key_rpt eingetragen und kann dann 
ausgewertet werden.
Wenn jetzt mehrere Tasten in REPEAT_MASK eingetragen sind kann jede 
einzelne dieser Tasten den "Timer" für key_rpt starten und somit werden 
alle gleichzeitig ausgewertet, sprich ich drücke Taste A lange und B, 
welche später gedrückt wird, wird sofort auch als lang erkannt ohne 
wieder REPEAT_START abzuwarten (beide in der REPEAT_MASK).
Wenn ich dieses Verhalten jetzt aber nicht haben will, sprich jede Taste 
isoliert betrachte, wie müsste man die Sache ähnlich effektiv angehen?
Klar ist das ich für jede Taste einen eigenen Timer brauche der 
unabhängig zu den anderen startet und überläuft.
Kann hier jemand einen Denkanstoß liefern bzw. wurde das gar schon 
irgendwo umgesetzt?

Danke!

Autor: Karl (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
würde gerne wenn die LED on ist erst wenn die taste 3 sec lang gedrückt 
wurde in den blink Modus schalten.

short key pressed funktioniert.

doch bei long key pressed passiert nichts.
wie muss ich den code verändern damit es funktioniert?

hab den code an mplabx angepasst. intosc 4mhz pic12f1572


#include <xc.h>
#include <stdbool.h>

//*** PIC12F1572 Configuration Bit Settings
// CONFIG1
#pragma config FOSC = INTOSC    // (INTOSC oscillator; I/O function on 
CLKIN pin)
#pragma config WDTE = OFF       // Watchdog Timer Enable (WDT disabled)
#pragma config PWRTE = ON       // Power-up Timer Enable (PWRT enabled)
#pragma config MCLRE = ON       // MCLR Pin Function Select (MCLR/VPP 
pin function is MCLR)
#pragma config CP = OFF         // Flash Program Memory Code Protection 
(Program memory code protection is disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable (Brown-out 
Reset disabled)
#pragma config CLKOUTEN = OFF   // Clock Out Enable (CLKOUT function is 
disabled. I/O or oscillator function on the CLKOUT pin)
//*CONFIG2
#pragma config WRT = OFF        // Flash Memory Self-Write Protection 
(Write protection off)
#pragma config PLLEN = ON       // PLL Enable (4x PLL enabled)
#pragma config STVREN = ON      // Stack Overflow/Underflow Reset Enable 
(Stack Overflow or Underflow will cause a Reset)
#pragma config BORV = LO        // Brown-out Reset Voltage Selection 
(Brown-out Reset Voltage (Vbor), low trip point selected.)
#pragma config LPBOREN = OFF    // Low Power Brown-out Reset enable bit 
(LPBOR is disabled)
#pragma config LVP = ON         // Low-Voltage Programming Enable 
(Low-voltage programming enabled)

// Pin assignments
#define LED    LATAbits.LATA2  // LED
#define BUTTON PORTAbits.RA4   // BUTTON

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

//#define KEY_DDR         TRISA   // DDRB
//#define KEY_PORT        LATA    // PORTB
#define KEY_PIN         PORTA  // PINB
#define KEY0            0
#define KEY1            4       // PORTAbits.RA4
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY0 | 1<<KEY1 | 1<<KEY2)     // repeat: 
key0, key1, key2
#define REPEAT_START    500                        // after 500 ms
#define REPEAT_NEXT     200                        // every 200 ms

#define LED_DDR         TRISA  // DDRA
#define LED_PORT        LATA   // PORTA
#define LED0            0
#define LED1            2      // LATAbits.LATA2
#define LED2            3

#define word unsigned int

volatile word key_state;                    // debounced and inverted 
key state:
                                            // bit = 1: key pressed
volatile word key_press;                    // key press detect
volatile word key_rpt;                      // key long press and repeat
static word ct0,ct1,rpt;
word i;

// global variables
static word wTMR0_count5 = 0;
static word wTMR0_count3 = 0;
bool boTMRflag5 = false;
bool boTMRflag3 = false;
bool HILF = false;
static word w1ms = 248;         // overflow factor

void interrupt isr(void)
{
    TMR0 = 256 - w1ms;               // increment interrupt count (every 
1000 us)

    ++wTMR0_count5;
    if (wTMR0_count5 == 500)         // if count overflow (every 500 ms)
    {
        wTMR0_count5 = 0;            // reset interrupt 500 ms count
        boTMRflag5 = true;            // set 500 ms Timer Flag
    }

    /*
    ++wTMR0_count3;
    if (wTMR0_count3 == 3000)       // if count overflow (every 3 sec)
    {
        wTMR0_count3 = 0;           // reset interrupt 3 sec count
        boTMRflag3 = true;
    }
    */

    i = key_state ^ ~KEY_PIN;                       // 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;
    }

    INTCONbits.TMR0IF = 0;                          // clear interrupt 
flag
}


///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
word get_key_press( word key_mask )
{
      di();                        // disable global interrupts
      key_mask &= key_press;       // read key(s)
      key_press ^= key_mask;       // clear key(s)
      ei();                        // enable global interrupts
      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.
//
word get_key_rpt( word key_mask )
{
      di();                        // disable global interrupts
      key_mask &= key_rpt;         // read key(s)
      key_rpt ^= key_mask;         // clear key(s)
      ei();                        // enable global interrupts
      return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
word get_key_state( word key_mask )
{
      key_mask &= key_state;
      return key_mask;
}

///////////////////////////////////////////////////////////////////
//
word get_key_short( word key_mask )
{
      di();                        // disable global interrupts
      return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
word get_key_long( word key_mask )
{
      return get_key_press( get_key_rpt( key_mask ));
}

///////////////////////////////////////////////////////////////////
//
word get_key_long2( word key_mask )
{
      return get_key_press( get_key_rpt( key_mask ));
}

int main(void)
{
    //*** Initialisation
    // configure port
    ANSELA = 0x00;               // set PortA digital
    //LED1 = 1;                    // Set RA2 high  -> LED off
    //TRISA = 0b00011011;          // set RA2 as output and RA4, RA5 as 
input

    LED_PORT = 0b00000100;       // Set RA2 high  -> LED off
    LED_DDR = 0b00011011;        // set RA2 as output and RA4, RA5 as 
input

    /*
    // Configure debouncing routines
    KEY_DDR &= ~ALL_KEYS;                // configure key port for input
    KEY_PORT |= ALL_KEYS;                // 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();
    */

    // configure oscillator
    OSCCONbits.SCS1= 1;          // select Internal oscillator block
    OSCCONbits.IRCF = 0b1101;    // Set Internal Oscillator to 4MHz HF
                                 // -> 1 us / instruction cycle

    // configure Timer0
    OPTION_REGbits.TMR0CS = 0;   // select timer mode
    OPTION_REGbits.PSA = 0;      // assign prescaler to Timer0
    OPTION_REGbits.PS  = 0b001;  // prescaling = 4, 255  1us  4
                                 // -> increment TMR0 every 1024 uss

    // enable interrupts
    INTCONbits.TMR0IE = 1;       // enable Timer0 interrupt
    ei();                        // enable global interrupts

    while(1)
    {

         if( get_key_short( 1<<KEY1 ))
             //LED_PORT ^= 1<<LED1;
             //LED_PORT &= ~(1 << LED1);
             HILF = ~HILF;

         /*
         if( get_key_long2( 1<<KEY1 ))
             //LED_PORT ^= 1<<LED2;
             HILF = 1;
         */

         /*
         // single press and repeat
         if( get_key_press( 1<<KEY1 ) || get_key_rpt( 1<<KEY1 ))
             HILF = 1;
         */

         if(!HILF)
         {
            if(boTMRflag5)
            {
               LED = ~LED;                  // toggle LED
               boTMRflag5 = false;          // clear 500 ms Timer Flag
            }
         }

         if(HILF)
         LED = 0;                          // Set RA2 low  -> LED on

    }

    return 0;
}

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl schrieb:
> würde gerne wenn die LED on ist erst wenn die taste 3 sec lang gedrückt
> wurde in den blink Modus schalten.

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;
    }
  }
}

Autor: EGS_TI (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Wie müsste man den Code ändern, damit man auf das Loslassen der Taste 
reagiert?
Wäre das so ohne weiteres möglich?

Autor: Uwe (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo EGS_TI,

eine Function dafür ist schon implementiert.

Autor: EGS_TI (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dann schau ich mir den Code jetzt nochmal an.

Autor: Arwed Reichel (arwedo)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ich benutze den Code für die Abfrage eines Türkontaktes. Dazu frage ich 
mit get_key_long(...) und get_key_release(...) ab. Beim Öffnen mit 
get_key_long(...) klappt das wunderbar: Tür auf, ca. 1s später reagiert 
die Software.
Allerdings reagiert der Release-Aufruf sofort, nicht erst, nachdem -- 
wie bei get_key_long(...) die repeat-Zeit verstrichen ist. Irgendwie 
fehlt mir noch eine Art get_key_release_long(...)-Funktion. Ich habe 
auch schon bissel'rumprobiert, aber das klappte irgendwie nicht. Aber im 
Code drin habe ich keine Funktion gefunden, die das schon machen würde. 
Uwe, welche meintest Du?
Viele Grüße ...

Autor: EGS_TI (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
EGS_TI schrieb:
> Hallo!
>
> Wie müsste man den Code ändern, damit man auf das Loslassen der Taste
> reagiert?
> Wäre das so ohne weiteres möglich?

In der original Datei von Peter ist das aber noch nicht implementier, 
oder bin ich blind?

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Guten Mittag,

bitte schau mal hier:

Beitrag "Re: Universelle Tastenabfrage"

Ok ?

: Bearbeitet durch User
Autor: Rolf Niepraschk (rolfn)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kann mir jemand einen Hinweis geben, wie man Peters Code so erweitern
kann, dass zusätzlich zum langen Drücken einer Taste auch noch das sehr
lange Drücken erkannt wird? (Soll als eine Art "reset" verwendet werden,
also nicht für die normale Bedienung.) Vielen Dank im voraus,

...Rolf

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Rolf Niepraschk schrieb:
> Kann mir jemand einen Hinweis geben

Wo ist Dein Problem?
Niemand hindert Dich daran, das entsprechende Bit in key_state zu testen 
und damit einen Zähler im Timerinterrupt hochlaufen zu lassen.

Autor: Rolf Niepraschk (rolfn)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke. Es funktioniert.

...Rolf

Autor: AnBo (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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!
#ifndef F_CPU
#define F_CPU 1000000UL
#endif

#define KEY_DDR         DDRA
#define KEY_PORT        PORTA
#define KEY_PIN         PINA
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define KEY3      3
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2 | 1<<KEY3)

#define REPEAT_MASK     (1<<KEY1)       // repeat: key0, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms

#define LED_DDR         DDRA
#define LED_PORT        PORTA
#define LEDBLUE         4
#define LEDYELLOW       5
#define LEDRED          6
#define LEDGREEN    7

#include <stdint.h>
#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>                // for _delay_ms()
#include <avr/interrupt.h>
#include "lcd.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 ^ ~KEY_PIN;                       // 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)
{  
  int displaystate=0;
  typedef enum
  {
    READY=0,
    STARTMEASUREMENT
  } current_state;

  current_state state = READY;

  LED_DDR = 0xFF;

  // Configure debouncing routines
  KEY_DDR &= ~ALL_KEYS;                // configure key port for input
  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors
  
  TCCR0B = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK0 |= 1<<TOIE0;                   // enable timer interrupt
  
  sei();
  
  lcd_init(LCD_DISP_ON);        // Initialize LCD
  
  while(1){
    switch (state)
    {
      case READY:
          if(displaystate==0){
            lcd_clrscr();
            lcd_puts("Bereit");
            displaystate=1;
          }
          LED_PORT = (1<<LEDGREEN);
          if( get_key_short( 1<<KEY3 )){
            displaystate=0;
            state=STARTMEASUREMENT;
          }
          if( get_key_long( 1<<KEY3 )){  
            displaystate=0;
            state=STARTMEASUREMENT;
          }
          break;
      
      case STARTMEASUREMENT:
          if(displaystate==0){
            lcd_clrscr();
            lcd_puts("State1");
            displaystate=1;
          }
          LED_PORT = (1<<LEDYELLOW);
          if( get_key_short( 1<<KEY2 )){
            displaystate=0;
            state=READY;
          }
          if( get_key_long( 1<<KEY2 )){
            displaystate=0;
            state=READY;
          }
          break;
        }
  }
}
        

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
AnBo schrieb:
> aber bist du sicher dass das so funktioniert?
> Ich habe das meiner Meinung nach genauso, allerdings passiert auf
> Tastendruck nichts.

Dein Code ist dermaßen verschieden zu meinem Beispiel, es wäre ein 
Wunder, wenn er genauso funktionierte.
Probier doch meinen einfach mal aus.

Autor: AnBo (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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!

Autor: Marc Vesely (Firma: Vescomp) (logarithmus)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Probier doch meinen einfach mal aus.

 LOL.

Autor: Mario Sachse (dachstuhlklaus)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Guten Tag zusammen.

Ich habe mich die letzen Tage mit dem hier vorgestellten Entprellcode 
auseinandergesetzt und möchte als erstes sagen:

"Danke an Peter Dannegger für diesen tollen code und an alle die ihn 
weiter verbessert haben!"

Zugegeben, ich habe nicht jede Zeile verstanden, aber weiss jetzt wie 
ich ihn anwenden kann. Vielleicht würde ja Zettel und Stift zu besserem 
Verständnis führen ;-)

Als kleines Dankeschön habe ich mir mal die Mühe gemacht alles hier 
zusammengetragene in eine Datei zu packen. Die Nutzung von mehreren 
Eingangsports, für mehr als acht Tasten, habe ich allerdings nicht 
eingebaut.

Da ich programmieren nur mit PICs gelernt habe, kann ich nur die 
Funktion dieses angehängten codes bestätigen (Simuliert mit Proteus). 
Wenn also mal jemand die Version für AVR kontrollieren könnte wäre das 
super. Ich habe es aber nach bestem Gewissen versucht umzusetzen.

Den Simulationsschaltkreis für Proteus habe ich auch angefügt. Also viel 
Spass damit :-)

Schöne Grüsse

Mario

@Peter Dannegger:
Darf ich den Code im CCS Forum posten? Unter Angabe der Quelle 
natürlich.

: Bearbeitet durch User
Autor: Pumba (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define F_CPU 8E6

#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms

#define LED_DDR         DDRA
#define LED_PORT        PORTA
#define LED0            0
#define LED1            1
#define LED2            2

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);

  i = key_state ^ ~KEY_PIN;                       // 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;
  }

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


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;
}

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;
}

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 )
{
  LED_DDR |= (1<<LED0) | (1<<LED1) | (1<<LED2);

  // Configure debouncing routines
  KEY_DDR &= ~ALL_KEYS;                // configure key port for input
  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors
  
  TCCR0B = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK0 |= 1<<TOIE0;                   // enable timer interrupt
  
  sei();
  
  while(1){
    if(get_key_short( 1<<KEY0 ))  // Led2 togglen
    LED_PORT ^= 1<<LED0;
    
    if( get_key_short( 1<<KEY1 ))  // Led1 togglen
    LED_PORT ^= 1<<LED1;

    if( get_key_short( 1<<KEY2 ))  // Leds loeschen
    LED_PORT &= ~((1<<LED0) | (1<<LED1));
  }
}

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nun Pumba?

Der KEY0 fehlt in der Definition.

Vielleicht solltest Du erstmal nur mit get_key_press() arbeiten.

Wenn Du das verstanden hast, kannst Du die zeitabhängigen 
Taster-Funktionen einbauen, konfigurieren und auch nutzen.

Ok ?

Autor: Mathias O. (m-obi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Pullups sind beim 841 bei PUE. Steht auch im Datenblatt. Bei mir 
hats damals funktioniert mit dem 841.

: Bearbeitet durch User
Autor: Pumba (Gast)
Datum:

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

Autor: Mathias O. (m-obi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Versuch mal anstatt so
key_state ^ ~KEY_PIN
das so zu machen
key_state ^ KEY_PIN

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mathias

dein Vorlag ist unsinning, wenn Du nicht weist wie der Code von PeDa 
funktioniert, dann rate bitte nicht.


Mathias O. schrieb:
> key_state ^ ~KEY_PINdas so zu machenkey_state ^ KEY_PIN

Autor: Mathias O. (m-obi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jo er hat ja die Taster active low. Dachte die sind an VCC 
angeschlossen.

Autor: Pumba (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.
  KEY_DDR &= ~ALL_KEYS;                // configure key port for input
  PUEB |= ALL_KEYS;
  //KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

Autor: Mathias O. (m-obi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mit welchem Wert hast du F_CPU definiert? 2278?

Autor: Pumba (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
F_CPU ist 8MHz

Autor: Mathias O. (m-obi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wo hängt dein Quarz dran? PB0 und PB1 sind doch XTAL.

Autor: Mathias O. (m-obi)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dann schreib mal 8000000UL bei F_CPU

Autor: Pumba (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: MikeD (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Servus,

Wiso ein "Glitch von 10ms" ?

Ich verstehe das Interruptsystem etwas anders:
Wenn der Timerinterrupt wieder aktiviert wurde, was ja nur ein paar µs 
dauert, springt man sofort in Timer Interrupt Routine, wenn das Timer 
Interrupt Flag gesetzt ist.

Klar können auch noch andere Interrupts mit höhere Priorität anstehen, 
die will ich jetzt nicht betrachten.

Autor: MikeD (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@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

Autor: Joachim B. (jar)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mario Sachse schrieb:
> "Danke an Peter Dannegger für diesen tollen code und an alle die ihn
> weiter verbessert haben!"

auch ich möchte noch mal Danke sagen für diese Entprellroutine.

Ich nutze sie im AVR, im Arduino

mal zum Tasten entprellen, klappt sogar an einer I2C LCD Schnitte mit 
PCF8574 die ich für 8 Tasten nutze.

Beschreibung,

Timer Interrupt 64µs für IRMP
wenn ein Counter auf 10ms hochgezählt hat wird in die I2C 
Tastaturabfrage gesprungen (100-200µs) dort wird ein Flag gesetzt das es 
ein langer IRQ wird, der Interrupt für IRMP wieder freigegeben und 
solange das Flag gesetzt ist am I2C Tastenabfragen vorbei gesprungen. 
Das Flag wird nur zurückgenommen wenn I2C wieder frei ist, der TWI 
Auftrag erledigt ist.

So entgeht mir kein IRMP Befehl, kein Tastendruck.

Für eine Laser Steuerung wo ausser den regulären 20Hz Impulsen mit 80µs 
Breite zur Lasertriggerung auch leider noch Fremdimpulse kommen unter 
10µs und fremd triggern habe ich nun die IRQ auf 10µs gesetzt wie eine 
Tastaturabfrage und trigger den Laser nur noch wenn ein solider Trigger 
größer 40µs erfolgt. Getestet mit einem Arduino als Pulsgenerator, ich 
kann F und Trigerbreite schön einstellen und sehen wie PeDas 
Entprellroutine wirkt.

: Bearbeitet durch User
Autor: Dave (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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
static volatile uint8_t IRQdoNotReadFlag;

uint16_t get_button_press(uint16_t button_mask) {
  IRQdoNotReadFlag = 1;
  button_mask &= button_press;
  button_press ^= button_mask;
  IRQdoNotReadFlag = 0;
  return button_mask;
}

in der Funktion die dann im IRQ aufgerufen wird:
void call_button_in_IRQ(void)                  // Call this in SysTick-Handler
{                                              // Should be called every 10ms
  static uint16_t ct0, ct1;
  #ifdef USE_KEY_REPEAT
    static uint16_t rpt;
  #endif
  uint16_t i;
  uint16_t BUTTON_MASK_NOW = BUTTON_PORT;    // get Stade of the InputDataRegister for the used Port
  if (!IRQdoNotReadFlag) {

    i = button_state ^ BUTTON_MASK_NOW;        // key changed ?
    ct0 = ~(ct0 & i);                          // reset or count ct0
    ct1 = ct0 ^ (ct1 & i);                     // reset or count ct1
    i &= ct0 & ct1;                            // count until roll over ?
    button_state ^= i;                         // then toggle debounced state
    button_press |= button_state & i;          // 0->1: key press detect
    
  #ifdef USE_KEY_REPEAT
    if ((button_state & REPEAT_MASK) == 0)     // check repeat function
      rpt = REPEAT_START;                    // start delay
    if (--rpt == 0) {
      rpt = REPEAT_NEXT;
      button_rpt |= button_state & REPEAT_MASK;
    }
  #endif
  }
}

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.

Autor: Uwe S. (de0508)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

bei den AVR µC kann man alle Interrupts Sperren und dann wieder 
freigeben, oder nur den zugehörigen Timer-Interrupt.
Die Abarbeitung des Timer-Interrupts wird dann nach seiner Freigabe 
"sofort" nachgeholt. Und geht nicht 'verloren'.

Bei deiner Realisierung in call_button_in_IRQ() geht aber dieser 
Interrupt verloren !
Also hier würde ich mal ansetzen.

Autor: Dave (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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
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.

Autor: Martin Lisc. (schrau_baer)
Datum:

Bewertung
-1 lesenswert
nicht lesenswert
Hallo Forumsmitglieder,

ich habe mich schon versucht an den Codebeispielen für Microchip PIC 
Mikrocontroller aber ich scheitere leider beim Aufruf der Funktionen.

Ich nutze 4 von 8 Pins des PORT A als Eingänge, der Rest sind Ausgänge. 
Compiler ist XC8 in Verbindung mit einem PIC16F628.

Beim Aufruf der Funktion in meinem Main Programm gibt mir der Compiler 
zu verstehen dass er "KEY1" nicht kennt.
if ( get_key_short( 1<<KEY1))
     i++;

Die Fehlercodes lauten:
(361) function declared implicit int
(192) undefined identifier "KEY1"

Gerne füge ich noch den Quellcode der "unbounce.c" diesem Post hinzu.

Gruß
Martin

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dave schrieb:
> Nun dachte ich mir, alle IRQs sperren ist etwas zu viel des Guten, es
> geht ja nur um das Auslesen der Tastenpins.

Wenn Dein IRQ so extrem zeitkritisch ist, daß er nicht mal eine 
Verzögerung um 2 CPU-Befehle verträgt, dann hast Du weitaus größere 
Probleme.

Autor: Martin Lisc. (schrau_baer)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So ich nochmal, nachdem ich den Fehler der richtigen Deklaration beheben 
konnte nun eine neue Herausforderung:

Es sind 4 Taster am PIC angeschlossen an RA0, RA1, RA6 und RA7 (alle als 
Input in den TRISA Regsiter gesetzt, der Rest des PortsA ist als Output 
deklariert)). Die Entprellroutine funktioniert auch zu 50% denn nur die 
letzten beiden Taster RB6&7 werden ausgewertet. Ich bin leider etwas 
verunsichert ob ich etwas falsch gemachte habe daher hier dier Code in 
voller Schönheit. Nicht wunder, es handelt sich um einen Microchip 
PIC16F628.

Hier der Inhalt der Headerdatei:
#ifndef UNBOUNCE_H
#define UNBOUNCE_H

#include "sw_spi.h"

#define KEY_PORT        PORTA               // Input register
#define KEY0            /*PORTAbits.RA*/1   // KEY 0...3
#define KEY1            /*PORTAbits.RA*/0   //
#define KEY2            /*PORTAbits.RA*/6   //
#define KEY3            /*PORTAbits.RA*/7   //

                        // Type all keys for repeat and long press function */
#define REPEAT_MASK     (1<<KEY0|1<<KEY1|1<<KEY2|1<<KEY3)
#define REPEAT_START    50   // After 500ms (start time long press)
#define REPEAT_NEXT     50   // Every 200ms (repeat time)
#define TIMEOUT              // Define when timout is needed for two
                             // keys pressed together

void interrupt service_interrupt(void);

uint8_t get_key_press( uint8_t key_mask );

uint8_t get_key_release(uint8_t key_mask);

uint8_t get_key_rpt( uint8_t key_mask );

uint8_t get_key_short( uint8_t key_mask );

uint8_t get_key_long( uint8_t key_mask );

uint8_t get_key_long_r( uint8_t key_mask );

uint8_t get_key_rpt_l( uint8_t key_mask );

uint8_t get_key_common( uint8_t key_mask );

#endif

Und hier nachfolgend die Funktionen:
#include "unbounce.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_release;              // Key release detected
volatile uint8_t key_rpt;                  // Key long press and repeat

//******************************************************************************
//                              INTERRUPTS
//******************************************************************************
//#INT_TIMER0                                     // Timer 0 interrupt
void  interrupt service_interrupt(void)
{
    TMR0=0x0064;                         // 156 x 64µs = 9.984ms (~10ms)
                                         // Preset 100 = 256 - 156
                                         //Setzt den Zählerstand auf x von 255
    static uint8_t ct0 = 0xFF, ct1 = 0xFF, rpt;
    uint8_t i;

    i = key_state ^ ~KEY_PORT;                  // Key changed ? active low key
    //i = key_state ^ KEY_PORT;                   // Active high key
    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
    key_release |= ~key_state & i;              // 1->0: key release 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;     // Active low keys
    }
    INTCONbits.T0IF=0; //Setzt das Interruptflag nach Zählerüberlauf zurück
}

//******************************************************************************
//                              FUNCTIONS
//******************************************************************************
//______________________________________________________________________________
// Button debounce routines
uint8_t get_key_press( uint8_t key_mask ){
    //disable_interrupts(GLOBAL);
    INTCONbits.GIE = 0;
    key_mask &= key_press;                      // Read key(s)
    key_press ^= key_mask;                      // Clear key(s)
    //enable_interrupts(GLOBAL);
    INTCONbits.GIE = 1;
    return key_mask;
}

uint8_t get_key_release(uint8_t key_mask){
    //disable_interrupts(GLOBAL);
    INTCONbits.GIE = 0;
    key_mask &= key_release;                    // Read key(s)
    key_release ^= key_mask;                    // Clear key(s)
    //enable_interrupts(GLOBAL);
    INTCONbits.GIE = 1;
    return key_mask;
}

uint8_t get_key_rpt( uint8_t key_mask ){
    //disable_interrupts(GLOBAL);
    INTCONbits.GIE = 0;
    key_mask &= key_rpt;                        // Read key(s)
    key_rpt ^= key_mask;                        // Clear key(s)
    //enable_interrupts(GLOBAL);
    INTCONbits.GIE = 1;
    return key_mask;
}

uint8_t get_key_short( uint8_t key_mask ){
    uint8_t i;
    //disable_interrupts(GLOBAL);
    INTCONbits.GIE = 0;
    i = get_key_press( ~key_state & key_mask );
    INTCONbits.GIE = 1;
    return i;
}

uint8_t get_key_long( uint8_t key_mask ){
    return get_key_press( get_key_rpt( key_mask ));
}

uint8_t get_key_long_r( uint8_t key_mask ){           // If repeat function needed
    return get_key_press( get_key_rpt( key_press & key_mask ));
}

uint8_t get_key_rpt_l( uint8_t key_mask ){            // If long function needed
    return get_key_rpt( ~key_press & key_mask );
}

uint8_t get_key_common( uint8_t key_mask ){
  return get_key_press((key_press & key_mask) == key_mask ? key_mask : 0);
}
;

Irgendwie will der Fehler sich mir nicht offenbaren.

Gruß

: Bearbeitet durch User
Autor: Moritz A. (moritz_a)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Um das Verhalten der "inneren" Variablen sowie der verschiedenen 
Abfrageroutinen mal genauer zu beobachten sowie damit zu experimentieren 
habe ich die ganze Routine mal in ein PC-taugliches C-Programm 
gewandelt.

Vielleicht kann damit ja noch jemand was anfangen.

Autor: Wuhu W. (wuhuuu2)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich verwendet die original Routine von Peter Dannegger und diese 
funktioniert perfekt.

Bevor ich es für mein Projekt versuche, funktioniert die Routine auch, 
wenn man z.B. 3 PINs als Ausgang schaltet.
Das bedeutet man wertet einen gesamten Port aus, der sowohl Ein als auch 
Ausgänge hat.

Können(und wenn ja welche?) Probleme auftreten?

Liebe Grüße

Autor: Joachim B. (jar)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wuhu W. schrieb:
> funktioniert die Routine auch,
> wenn man z.B. 3 PINs als Ausgang schaltet.

ja

Wuhu W. schrieb:
> Das bedeutet man wertet einen gesamten Port aus, der sowohl Ein als auch
> Ausgänge hat.

aber das Ergebnis wird mit den definierten KEYs (Eingänge) oder bei der 
Abfrage *) verundiert, je nach dem ob high- oder low- aktiv, bei Abfrage 
auf high ver"unden", bei Abfrage auf low negiert ver"unden"

*) ret_key=get_key_press( ALL_KEYS ); // welche Taste(n) will ich 
wissen?
// key.h -----------------------

#ifndef KEY_H
#define KEY_H

uint8_t get_key_press( uint8_t );
uint8_t get_key_rpt( uint8_t );
uint8_t get_key_short( uint8_t );
uint8_t get_key_long( uint8_t );
uint8_t test_i2c_key(void);
//void timer2_init(void);

extern volatile uint8_t key_state;  // debounced and inverted key state:
                                    // bit = 1: key pressed
extern volatile uint8_t key_press;  // key press detect
extern volatile uint8_t key_rpt;    // key long press and repeat
extern volatile uint8_t ct0, ct1, rpt;
extern volatile uint8_t key;


// --------------- KEY --------------- 
#if defined(__AVR_ATmega328P__)
  // D5 (T1)        PD5
  #define KEY_DDR     DDRD
  #define KEY_PORT    PORTD
  #define KEY_PIN     PIND
  #define KEY_UP         5
  // D6 (AIN0)      PD6
  #define KEY_DOWN       6
  // D7 (AIN1)      PD7
  #define SET_TASTE      4

  // D8 (ICP1)      PB0
  // D9 (OC1A)      PB1 (PWM)
#endif

#define ALL_KEYS         (1<<KEY_UP | 1<<KEY_DOWN | 1<<SET_TASTE)
 
#define REPEAT_MASK     (1<<KEY_UP | 1<<KEY_DOWN)
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     15                        // every 200ms

extern volatile uint8_t key_state;  // debounced and inverted key state:
                                    // bit = 1: key pressed
extern volatile uint8_t key_press;  // key press detect
extern volatile uint8_t key_rpt;    // key long press and repeat
extern volatile uint8_t ct0, ct1, rpt;

#endif // #ifndef KEY_H
// key.h -----------------------

// isr -----------------------
    ii = key_state ^ ~KEY_PIN;
    ct0 = ~( ct0 & ii );                             // reset or count ct0
    ct1 = ct0 ^ (ct1 & ii);                          // reset or count ct1
    ii &= ct0 & ct1;                                 // count until roll over ?
    key_state ^= ii;                                 // then toggle debounced state
    key_press |= key_state & ii;                     // 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;
    }
// isr -----------------------

// loop -----------------------
  ret_key=get_key_press( ALL_KEYS );

  if(ret_key&(1<<SET_TASTE))
  { ret_key&=~(1<<SET_TASTE); // ~ Port IN negiert weil low Abfrage
// loop Auschnitt -----------------------


Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wuhu W. schrieb:
> Können(und wenn ja welche?) Probleme auftreten?

Die Entprellung ist je Pin unabhängig.
D.h. auch 7 Out-Pins sind dem einen In-Pin völlig wurscht.
Nur die Maske für Repeat-Funktion will nur die aktiven Inputs sehen.

Autor: Christian F (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Simpel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Bastler (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Simpel (Gast)
Datum:

Bewertung
-1 lesenswert
nicht lesenswert
@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.

Autor: Karl M. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Moby AVR (moby-project) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl M. schrieb:
> Bitte schreibe, als Beweis

Was soll er beweisen? Denn

Simpel schrieb:
> Es ging mir nur um die simple Betrachtung des reinen Entprellens

Mit seiner entsprechenden (simplen) Problemlösung hat er ganz recht, da 
brauchts doch nicht mehr (erwähnte fehlende Störeinstreuungen 
vorausgesetzt).

: Bearbeitet durch User
Autor: T.G. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: T.G. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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
#pragma code
#pragma interrupt high_prior_InterruptHandler

void high_prior_InterruptHandler(void)
{}

#pragma code
#pragma interrupt low_prior_InterruptHandler
void low_prior_InterruptHandler(void)
{}

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.
#pragma code
#pragma interruptlow low_prior_InterruptHandler
void low_prior_InterruptHandler(void)
{}
Das ist also korrekt. Und jetzt funktioniert es auch :)

Autor: AVR-Bastler (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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:
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
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.

Autor: chris (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Folgender Code funktioniert bei mir einwandfrei:


static uint8_t lcd_update = 0;
static char buffer[20];
static uint32_t counter = 0;

      // decrement
      if (get_key_press(1<<KEY_DEC))
      {
        if (counter > 0)
        {
          counter--;
          lcd_update = 1;
        }
      }
      if (get_key_rpt(1<<KEY_DEC))
      {
        if (counter >= 10)
        {
          counter -= 10;
        }
        else
        {
          counter = 0;
        }
        
        lcd_update = 1;
      }


      if (lcd_update)
      {
        lcd_update = 0;
        lcd_setcursor(0,1);
        sprintf(buffer, "%16" PRIu32 "", counter);
        lcd_string(buffer);
      }


lg
Chris

Autor: AVR-Bastler (Gast)
Datum: