Debounce - LED leuchten lassen

[Andreas (Gast)]

Hallo Leute!

Ich habe aus dem AVR-GCC-Tutorial die Entprell-Routine genommen und mir 
ein Programm geschrieben, welches folgendes bezwecken soll:

Ich habe einen ATTiny25 in Verwendung, an dem 3 Taster angeschlossen 
werden sollen.

Wenn Taster 0 gedrückt wird, soll die LED 500 ms leuchten,
Wenn Taster 1 gedrückt wird, 2000 ms leuchten
Wenn Taster 2 gedrückt wird, 3000 ms leuchten.


Die LED ist an PINB3 angeschlossen (siehe Quellcode).

Könntet ihr mir sagen, ob das Programm so funktionieren würde?

#include <avr/io.h>
#include <util/delay.h>



void entprellung (volatile uint8_t *port, uint8_t maske ) 
{
  uint8_t   port_puffer;
  uint8_t   entprellungs_puffer;
 
  for(entprellungs_puffer=0;entprellungs_puffer!=0xff;) 
  {
    entprellungs_puffer<<=1;
    port_puffer = *port;
    _delay_us(150);
    
  if((*port & maske) == (port_puffer & maske) )
  {
      entprellungs_puffer |= 0x01;
  }
  }
} 


void main (void)
{
  DDRB = 0;          // alle Pins als Eingang schalten
  DDRB |= (1<<PINB3);      // nur Pin3 (Port B) auf Ausgang schalten

  while(1)
  {
  
      entprellung( &PINB, (1<<PINB0) ); // ggf. Prellen abwarten 
      if( PINB & (1<<PINB0) )           // dann stabilen Wert einlesen
      {
        PORTB |= (1<<PINB3);       // wenn Taster0 gedrückt wurde....
      delay_ms(500);           // Licht einschalten, 500 ms warten, dann ausschalten
      PORTB &= ~(1<<PINB3);
      
      }

      entprellung( &PINB, (1<<PINB1) );
    if( PINB & (1<<PINB1)) 
    {

      PORTB |= (1<<PINB3);
      delay_ms(2000);
      PORTB &= ~(1<<PINB3);
    }

      entprellung( &PINB, (1<<PINB2) );
    if( PINB & (1<<PINB2)) 
    {
      PORTB |= (1<<PINB3);
      delay_ms(3000);
      PORTB &= ~(1<<PINB3);      

    }

}

}

Vielen Dank und Gruß
Andreas

[Rufus Τ. F. (rufus)]

> Könntet ihr mir sagen, ob das Programm so funktionieren würde?

Was hält Dich davon ab, es einfach auszuprobieren?

[Andreas (Gast)]

Hey,

das Problem ist, dass ich hier im Moment keine Möglichkeit habe, 
Hardware aufzubauen.
Da die Steuerung einem Bekannten von mir gehört, die er bereits gelötet 
hat und er mich "beauftragte", die Software zu schreiben, wollte ich 
zunächst erfragen, ob das Programm soweit gut aussieht?!

Bevor ich etwas übergebe, was nicht funkioniert :)

Außerdem seit ihr ja quasi die besten Hardware-Emulanten und wisst wo 
der Fehler liegt ;-)


Gruß
Andreas

[Peter D. (peda)]

Andreas schrieb:
> entprellung( &PINB, (1<<PINB0) ); // ggf. Prellen abwarten
>       if( PINB & (1<<PINB0) )           // dann stabilen Wert einlesen

Da dreht sich mir der Magen um.

Du liest den Pin nur einmal ein, warum soll er ausgerechnet dabei stabil 
sein?
Bist Du etwa Hellseher?
Die Entprellung machen indirekt nur Deine Monsterdelays >=500ms danach.

Eine zuverlässige Entprellung erreicht man nur durch Mehrfachabtastung 
in beide Richtungen (drücken + loslassen). Und vorzugsweise im 
Timerinterrupt, damit keine wertvolle CPU-Zeit unnütz verwartet wird.


Peter

[Andreas (Gast)]

Ähm wofür dient dann das Beispiel im Tutorial?


Außerdem ist es dort genauso beschrieben, wie ich es in meinem Programm 
auch gemacht habe.

[Peter D. (peda)]

Andreas schrieb:
> Ähm wofür dient dann das Beispiel im Tutorial?

Welches denn?
Zeig mal den Link darauf.
Ich sehe da keines, welches den Typ void liefert.

Auch heißt es nicht, wenn etwas im Tutorial steht, daß es unbedingt 
richtig ist oder wirklich gut funktioniert. Das Tutorial schreiben ja 
auch nur Menschen.


Gerade beim Entprellen wird sehr viel Murks gemacht, weil der 
Programmierer es nicht verstanden hat und es auch nicht merkt, solange 
die Tasten neu sind.
Erst der Kunde merkt es mit der Zeit, wenn die Tasten ermüden und 
oxydieren.
Auch Du kennst bestimmt Geräte mit schlecht entprellender 
Tastensoftware.


Peter

[Andreas (Gast)]

Hallo,

hier der Link mit dem Quellcode aus dem Tutorial:

http://www.mikrocontroller.net/articles/Entprellung#Warteschleifen-Verfahren



Aber gibt es denn keine Routine, die einfach und trotzdem hilfreich ist?

Das ist ja eigentlich das Grundlegendste, einen Taster an einem 
Controller abzufragen....


Gruß

[Peter D. (peda)]

Andreas schrieb:
> http://www.mikrocontroller.net/articles/Entprellun...

Ja, die ist schlecht.
Ihre Hauptaufgabe ist, bei jedem Aufruf >= 1.2ms zu verschwenden.
Das Einlesen eines Ports kann jedesmal einen anderen Wert liefern. Das 
mag vielleicht selten passieren, aber es kann. Insbesondere wenn Du 
Interrupts verwendest, steigt die Gefahr. Da kann ja zwischen den 
Einlesungen schon viel Zeit (Interrupthandler: mehrere ms) vergangen 
sein.
Daher sollte die Entprellroutine immer auch den Erfolg direkt als 
Rückgabewert liefern.
Unnötige Mehrfacheinlesungen eines Ports sind unbedingt zu vermeiden!


Andreas schrieb:
> Aber gibt es denn keine Routine, die einfach und trotzdem hilfreich ist?

Gibt es:
http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29

http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_type=project&item_id=1801

http://www.mikrocontroller.net/articles/Entprellung#Debounce-Makro_von_Peter_Dannegger


Andreas schrieb:
> Das ist ja eigentlich das Grundlegendste, einen Taster an einem
> Controller abzufragen....

Das schon. Allerdings denken wohl viele Programmer, das ist nicht so 
wichtig, als das man es richtig machen müßte.
Oder die Programmierer lernen zwar viel über Software, aber haben wenig 
Wissen über Hardware.


Peter

[Andreas (Gast)]

Nun mach' ich es mit Hardware.

Diese unkommentierten kryptischen Codes mag ich nicht, da ist mir ein 
Kondensator und ein Widerstand deutlich sympathischer und ich 
verschwende dabei keine Ressourcen vom Mikrocontroller.

[Andreas (Gast)]

Hallo,


habe hier mal einen Schaltplan gezeichnet (Eagle).

Im Anhang findet ihr das PDF.


Könnte mal bitte jemand drüber schauen ob das so in Ordnung ist?
(Auch die Debounce-Schaltungen)






Vielen Dank!

Gruß
Joh

[A. F. (frankalicious)]

Andreas schrieb:
> Diese unkommentierten kryptischen Codes mag ich nicht,

Unkommentiert?
Hier sind doch Kommentare im Code und die Funktionsweise ist auch noch 
erläutert...
http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29

[Andreas (Gast)]

Stimmt die Schaltung so?

[Andreas (Gast)]

Hallo nochmal,

ich habe nun diesen Quellcode von Peter Dannegger verwendet und 
"umgeschrieben", für meine Bedürfnisse.

/************************************************************************/
/*                                                                      */
/*                      Not so powerful Debouncing Example              */
/*                      No Interrupt needed                             */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                                                                      */
/************************************************************************/
// Target: ATtiny13
 
#include <avr/io.h>
#define F_CPU 9.6e6
#include <util/delay.h>
 
 
#define debounce( port, pin )                                         \
({                                                                    \
  static uint8_t flag = 0;     /* new variable on every macro usage */  \
  uint8_t i = 0;                                                      \
                                                                      \
  if( flag ){                  /* check for key release: */           \
    for(;;){                   /* loop ... */                         \
      if( !(port & 1<<pin) ){  /* ... until key pressed or ... */     \
        i = 0;                 /* 0 = bounce */                       \
        break;                                                        \
      }                                                               \
      _delay_us( 98 );         /* * 256 = 25ms */                     \
      if( --i == 0 ){          /* ... until key >25ms released */     \
        flag = 0;              /* clear press flag */                 \
        i = 0;                 /* 0 = key release debounced */        \
        break;                                                        \
      }                                                               \
    }                                                                 \
  }else{                       /* else check for key press: */        \
    for(;;){                   /* loop ... */                         \
      if( (port & 1<<pin) ){   /* ... until key released or ... */    \
        i = 0;                 /* 0 = bounce */                       \
        break;                                                        \
      }                                                               \
      _delay_us( 98 );         /* * 256 = 25ms */                     \
      if( --i == 0 ){          /* ... until key >25ms pressed */      \
        flag = 1;              /* set press flag */                   \
        i = 1;                 /* 1 = key press debounced */          \
        break;                                                        \
      }                                                               \
    }                                                                 \
  }                                                                   \
  i;                           /* return value of Macro */            \
})
 
/*
   Testapplication
 */
int main(void)
{
  
  DDRB  &= ~(1<<PB0);    // Eingang 1 (Taster)
  DDRB  &= ~(1<<PB1);    // Eingang 2 (Taster) 
  DDRB  &= ~(1<<PB2);    // Eingang 3 (Taster)   
  DDRB  |=   1<<PB3;     // Ausgang (LED)
  

  whie(1)
  {
    if( debounce( PINB, PB0 ) )     // wenn Taster 1 gedrückt...
    {
      PORTB |= 1<<PB3;              // Am Ausgang HIGH ausgeben
      _delay_ms(500);               // warten...
      PORTB &= ~(1<<PB3);           // Ausgang auf LOW schalten
    } 
    
    if( debounce( PINB, PB1 ) )     // wenn Taster 2 gedrückt...
    {
      PORTB |= 1<<PB3;
      _delay_ms(1000);
      PORTB &= ~(1<<PB3);
    }     

    if( debounce( PINB, PB2 ) )      // wenn Taster 3 gedrückt...
    {
      PORTB |= 1<<PB3;
      _delay_ms(2000);
      PORTB &= ~(1<<PB3);
    }     


}

Ich habe nun die Taster direkt an 5 V gehängt und schalte somit beim 
Drücken des Tasters 5 V auf den Eingang des Controllers.

Stimmt nun der Quellcode zum Entprellen (laut Tutorial)?



Danke!

Gruß
Andreas

[Peter D. (peda)]

Andreas schrieb:
> Ich habe nun die Taster direkt an 5 V gehängt und schalte somit beim
> Drücken des Tasters 5 V auf den Eingang des Controllers.

Dann ist die Preisfrage aber, was liegt an bei Losgelassen ???

Die Leute sind ja nicht blöd, die den Taster gegen GND legen und im AVR 
den Pullup einschalten.


Peter