Tasterentprellung

void debounce_switch()
{
  uint8_t debounce_count = 0;

  for(int i=0; i<8; ++i)
  {
    _delay_us(50);
    if(!(PINB & (1<<PINB0)))
      ++debounce_count;
    else
      debounce_count = 0;
  }
}

Will meinen Taster bzw. mehrere Taster im Main Loop dauernd abfragen...

void debounce_switch()
{
  for(uint8_t debounce_count=0; debounce_count<8; ++debounce_count)
  {
    _delay_us(50);
    if(!(PINB & (1<<PINB0)))
      ++debounce_count;
    else
    {
      debounce_count = 0;
      break;
    }
  }
}

Sorry... Aber das wäre der Code

uint8_t debounce_switch(volatile uint8_t *port, uint8_t pin)
{
  for(uint8_t debounce_count=0; debounce_count<8; ++debounce_count)
  {
    _delay_us(500);
    if(*port & (1<<pin))
    {
      debounce_count = 0;
      return 0;
    }
  }

  return 1;
}

Habe es jetzt so abgeändert... Brauch es nur um einen Tastendruck zu 
entprellen, das loslassen ist uninteressant. Wenn der Schalter gedrückt 
wird, geht der Pin auf Massepegel.

Danke

uint8_t debounce_switch(volatile uint8_t *port, uint8_t pin)
{
  for(uint8_t debounce_count=0; debounce_count<8; ++debounce_count)
  {
    _delay_us(500);
    if(*port & (1<<pin))
    {
      return 0;
    }
  }

  return 1;
}

Moin,

mal eine Frage aus Interesse:

was ist eigentlich so furchtbar an einer Hardware-Entprellung?

Es gibt hier eine Vielzahl von Beiträgen zur Software-Enprellung.

Ein schnödes RC-Glied pro Taster (so viele von den Dingern verbaut man 
ja auch nicht), und das Problem ist an der Wurzel gelöst.

Software-Entprellung ist doch nur das Doktern an Symptomen, ohne die 
Ursache zu beseitigen.

Oder übersehe ich irgendwas wichtiges?

Liebe Grüße aus der Wesermarsch

Ralph

if(!(PINB & (1<<PINB3)))
  {
    if(debounce_switch(&PINB, PINB3))
                {
                    ....
                }
                else
                {
                    ....
                }

         }

@Karl heinz Buchegger: So nutze ich meine Funktion... Habe ich vergessen 
zu erwähnen...

Danke!

Ralph Fischer schrieb:
> was ist eigentlich so furchtbar an einer Hardware-Entprellung?
>
> Es gibt hier eine Vielzahl von Beiträgen zur Software-Enprellung.
>
> Ein schnödes RC-Glied pro Taster (so viele von den Dingern verbaut man
> ja auch nicht), und das Problem ist an der Wurzel gelöst.
>
> Software-Entprellung ist doch nur das Doktern an Symptomen, ohne die
> Ursache zu beseitigen.

Wenn schon Hardware-Entprellung, dann aber richtig und kein 
"funktioniert solange Taster neu ist" RC Glied.
Nämlich ein Umschalttaster und ein RS Flipflop.

Ansonsten haben Karl Heinz und Carsten schon alles gesagt.

Moin Jungs,

nur damit keine Mißverständnisse aufkommen: ich habe nicht behauptet, 
daß HW-Entprellung das einzig Senkrechte wäre. Das war wirklich eine 
neugierige Frage.

Bisher habe ich RC-Glieder mit ca. 15 Hz Grenzfrequenz genommen (weil 
menschliche Muskeln nicht schneller als 7 Hz können). Funktioniert auch 
in einer 30 Jahre alten Z80-Mimik noch tadellos.

Das war wohl mit

> "funktioniert solange Taster neu ist"

gemeint.

> Nämlich ein Umschalttaster und ein RS Flipflop.

Tja, und ab hier gefällt mir Software dann auch besser ;-)

Zusatzfrage: gibts von der Dannegger-Entprellung irgendwo eine 
Darstellung als Flußdiagramm?
Ich beherrsche nur Bascom und Z80-Assembler (letzteres schon einige 
Monde eingerostet). Dann könnte ich mir das mal nachhäkeln...

Herzlichen Dank und Ende der Fred-Kaperung :-)

Liebe Grüße aus der Wesermarsch

Ralph

Karl heinz Buchegger schrieb:
> Du stellst nur fest, ob die Taste gedrückt ist. Und wenn du 2000 mal in
> der Sekunde nachsiehst ob die Taste gedrückt ist, dann führst du auch
> deinen Ausführungsteil 2000 mal aus.

Nope...
Die if(!(PINB & (1<<PINB3))) ist nur wahr wenn der Taster gedrückt 
wird... Ansonsten liegt an meinem Eingang ein High-Pegel an... Mich 
interessiert auch nur der Tastendruck also der Pegelwechsel von High auf 
Low an meinem Eingang.

Peter Dannegger schrieb:
> Genau.
> Und dann gibt debounce() jedesmal 1 zurück.
> Eine Flankenerkennung erfolgt nicht.
>
> Du kriegst alle 500µs * 8 = 4ms ne 1 solange Du drückst und nicht nur
> beim Wechsel der Taste zu gedrückt.
>
>
> Peter

Genau, aber wenn ich die Taste drücke, tue ich dies bewusst... Die 
Funktion ist quasi ein EMV Schutz...Meiner Meinung nach erkenne ich den 
Flankenwechsel mit einer kontinuierlichen Abfrage ala: if(!(PINB & 
(1<<PINB3)))...
Wenn ein Puls in meinen Eingang haut, wird diese Bedingung auch wahr, 
aber die debounce_switch liefert dann hoffentlich eine 0.

Herr Buchegger,

ich habe das Problem erkannt. Sie haben Recht.
Ich sehe aber gerade keine (andere) Möglichkeit den Flankenwechsel zu 
detektieren.
Ich habe mir das immer so vorgestellt:

Mein Standardzustand:
PINB3 = 1;

Nach Tastendruck:
PINB3 = 0;
nichts anderes bedeutet die Abfrage: if(!(PINB &(1<<PINB3))), oder?

Meine Abfrage im Main Loop:
PINB3 == 0 ? debounce_switch() : 0;

Meine debounce_switch() soll lediglich einem nicht durch einen Menschen 
ausgeführten Tastendruck filtern. Über die _delay_us() Zeit kann man 
streiten.

Was habe ich sonst für Möglichkeiten den Flankenwechsel zu erkennen?

Danke, hatte den Rest noch gar nicht gelesen...

void switch_state()
{
if(!(PINB & (1<<PINB3)) && switch_no != 0)
{
    if(debounce_switch(&PINB, PINB3))
    {
        ....
        switch_no = 0;
    }
}

if(!(PINB & (1<<PINB4)) && switch_no != 1)
{
    if(debounce_switch(&PINB, PINB3))
    {
        ....
        switch_no = 1;
    }
}
}

So müsste das dann aussehen...

void switch_state()
{
if(!(PINB & (1<<PINB3)) && switch_no != 0)
{
    if(debounce_switch(&PINB, PINB3))
    {
        ....
        switch_no = 0;
    }
}

if(!(PINB & (1<<PINB4)) && switch_no != 1)
{
    if(debounce_switch(&PINB, PINB4))
    {
        ....
        switch_no = 1;
    }
}
}

F**k copy & paste...

Jetzt aber..

Ok, vielen Dank!!!