Gelöst: Komfortroutine C - Taster entprellen

[Stefan S. (sschultewolter)]

Hallo,

ich habe das Problem, dass sich der Status über die Leds nicht ändert. 
Sobald das Programm startet, werden die Ausgänge der Leds HIGH gesetzt 
und danach bleiben diese unverändert. Sie reagieren nicht auf die 
Tastendrücke.

Die Taster sind als Low-Active angeschlossen

                            T
                ___        ---
 VCC ----------|___|--o----o o---------- GND
                10k   |
                      '----------- INPUT MCU

                ___         LED
 OUTPUT MCU ---|___|-------->|- -------- GND
                680
(created by AACircuit v1.28.6 beta 04/19/05 www.tech-chat.de)

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      [e-mail]                                  */
/*                                                                      */
/************************************************************************/

#define F_CPU 16000000UL

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

#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            0    // Arduino Pro Mini Pin 8 | PB0
#define KEY1            1    // Arduino Pro Mini Pin 9 | PB1
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1)

#define REPEAT_MASK     (1<<KEY1) 
#define REPEAT_START    50
#define REPEAT_NEXT     20

#define LED_DDR         DDRD
#define LED_PORT        PORTD
#define LED0            2    // Arduino Pro Mini Pin 2 | PD2
#define LED1            3    // Arduino Pro Mini Pin 3 | PD3

volatile uint8_t key_state;
volatile uint8_t key_press;
volatile uint8_t key_rpt;


ISR( TIMER0_OVF_vect )
{
  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;    // LOW ACTIVE
  //i = key_state ^ KEY_PIN;    // HIGH ACTIVE    
  ct0 = ~( ct0 & i );
  ct1 = ct0 ^ (ct1 & i);
  i &= ct0 & ct1;
  key_state ^= i;
  key_press |= key_state & i;
  
  if( (key_state & REPEAT_MASK) == 0 )
  rpt = REPEAT_START;
  if( --rpt == 0 )
  {
    rpt = REPEAT_NEXT;
    key_rpt |= key_state & REPEAT_MASK;
  }
}

uint8_t get_key_press( uint8_t key_mask )
{
  cli();
  key_mask &= key_press;
  key_press ^= key_mask;
  sei();
  return key_mask;
}

uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();
  key_mask &= key_rpt; 
  key_rpt ^= key_mask;
  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();
  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 = 0xFF;
  LED_DDR = 0xFF;
  
  KEY_DDR &= ~ALL_KEYS;
  KEY_PORT |= ALL_KEYS; 
  
  TCCR0A = (1<<CS02)|(1<<CS00);
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);
  TIMSK0 |= 1<<TOIE0;
  
  sei();
  
  while(1)
  {
    if( get_key_short( 1<<KEY0 ))
    LED_PORT ^= 1<<LED0;
    
    if( get_key_long( 1<<KEY1 ))
    LED_PORT ^= 1<<LED1;
  }
}

[Stefan S. (sschultewolter)]

Also an den Leds liegt es nicht, habe die nun anders getestet. Die 
Taster machen jedoch immer noch nicht, was ich von Ihnen möchte.

Habe diese ohne Entprellen getestet und es ging.

[Thomas H. (Firma: CIA) (apostel13)]

Ich persönlich hab noch nie ganz verstanden warum so oft so großer 
proceduraler Aufwand betrieben wird um softwaremässig zu entprellen. Ein 
Kondensator und ein Wiederstand mehr reichen und man muss nichts in der 
SW entprellen. Eine ISR dafür zu nehmen ist eh übertrieben und schade um 
den INtrrupt.

[michi (Gast)]

Warum probierst du nicht einfach _delay_ms(50);

if(taste high)
{_delay_ms(x);
led ein;
}

X durch probiern auswaehlen..

Mach ich bei Matrixtastatur etc. immer so und hab noch keinen Nachteil 
festgestellt.

Undja das ist nicht ideal aber fuer ne led find ich eine ISR 
uebertrieben ;)

[Stefan S. (sschultewolter)]

@Thomas Holmes:
Sicherlich ist es meist auch ausreichend mit einem Kondensator sowie 
Widerstand an dem Taster. Habe das auch bereits ein paar mal zu 
testzwecken gemacht. Geht an sich auch immer ganz gut. Es sind aber 
somit auch 2 Bauteile mehr. Im Tutorial wird darauf hingewiesen, dass es 
kaum noch einen Sinn macht, da die Software das auch auswerten kann. Das 
soll keine Diskussion über den Sinn nun geben ;)

@michi:
Solche Sachen mit den delays versuche ich wenn möglich immer zu 
vermeiden, auch wenn das hier natürlich kaum ins Gewicht fällt.

Ich habe einen ähnlichen Code vor ein paar Wochen geschrieben. (Der 
Atmega328P 16MHz diente lediglich zum kurzen Testen). Das ganze wurde 
mit einem Attiny85 betrieben. Der Code gibt nicht alles wieder. Die 
ganzen anderen Bibiotheken werden über die main.h einbezogen.

Ich habe vom Prellen nichts mitbekommen bei dieser Methode. Ich habe 
hier bereits einen Timer im Einsatz für die Zeit-funktion. In der habe 
ich ich Millisekunden, Sekunden, Minuten und Stunden, die über einem 
Interupt-Overflow gezählt werden. Basierend auf dem millis Zähler werden 
auch diverse Frequenzen zur Verfügung gestellt. U.a. 50Hz. Ich habe hier 
keinerlei Probleme mit dem Entprellen feststellen können. Nichts wurde 
doppelt gezählt.

Gäbe es ansonsten Anregungen, wie ich ggf. falsche Rückgabewerte 
vermeiden kann in diesem Beispiel? Für die fertige Version plane ich mit
http://www.mikrocontroller.net/wikifiles/f/f8/RC_debouncer.png Die 
Schmitt-Trigger ICs stehen jedoch derzeit erst einmal nur auf der 
Möchte-Haben-Liste und sind noch nicht bestellt.

/*
ATtiny85_Equinox.c
Created: 31.07.2014 16:16:07
Author: sschultewolter

(PCINT5/!RESET/ADC0/dW)      PB5  1  | AT |  8  VCC
(PCINT3/XTAL1/CLKI/!OC1B/ADC3)  PB3  2  | TI |  7  PB2  (SCK/USCK/SCL/ADC/T0/INT0/PCINT2)
(PCINT4/XTAL2/CLKO/OC1B/ADC2)  PB4  3  | NY |  6  PB1  (MISO/DO/AIN1/OC0B/OC1A/PCINT1)
________________________________GND  4  | 85 |  5  PBO (MOSI/DI/SDA/AIN0/OC0A/!OC1A/AREF/PCINT0)

PB1 - WS2812B
PB3 - Button1
PB4 - Button2
*/

#include "main.h"

int main(void)
{
  time_init();
  //time_set(0, 15, 30);
  
  DDRB &= ~((1 << DDB3) | (1 << DDB4));  // PB3 + PB4 als Eingang
  PORTB |= ((1 << PB3) | (1 << PB4));    // PB3 + PB4 PullUp aktivieren
  
  while(1)
  {
    //>-- Zu Testzwecken mit != 0 initialisiert
    static int16_t mode1=10;
    static int16_t mode2=5;
    //<--
    
    {
      static int8_t ct_button1;
      static int8_t ct_button2;
      
      int8_t state_button1;
      static int8_t lastState_button1;
      
      int8_t state_button2;
      static int8_t lastState_button2;
      
      static int16_t lastChange;
      if(frequency_50 != lastChange)    // alle 20ms
      {
        lastChange = frequency_50;
        
        state_button1 = !(PINB & (1 << PINB3));
        state_button2 = !(PINB & (1 << PINB4));
        
        if(state_button1) ct_button1++;
        else if(!state_button1 && lastState_button1)
        {
          if(ct_button1 > 50) mode1++;
          else mode2++;
          ct_button1 = 0;
        }
        lastState_button1 = state_button1;
        
        if(state_button2) ct_button2++;
        else if(!state_button2 && lastState_button2)
        {
          if(ct_button2 > 50) mode1--;
          else mode2--;
          ct_button2 = 0;
        }
        lastState_button2 = state_button2;
        
        //--> Visuelles Debugging
        leds_clear();
        leds_rgb(leds_index(mode1), 255,0,0);
        leds_rgb(leds_index(mode2), 0,0,255);
        leds_on();
        //<--
      }
    }
  }
  
  return 0;
}

[Thomas H. (Firma: CIA) (apostel13)]

Stefan S. schrieb:
> icherlich ist es meist auch ausreichend mit einem Kondensator sowie
> Widerstand an dem Taster. Habe das auch bereits ein paar mal zu
> testzwecken gemacht. Geht an sich auch immer ganz gut. Es sind aber
> somit auch 2 Bauteile mehr. Im Tutorial wird darauf hingewiesen, dass es
> kaum noch einen Sinn macht, da die Software das auch auswerten kann. Das
> soll keine Diskussion über den Sinn nun geben ;)

Hallo, nein diskutieren will ich auch nicht. Schließlich ist weder das 
was im Tutorial steht, noch meine persönliche Meinung ein Gesetz. Jeder 
hat so seine Strategie. Meine ist es immer den geringsten 
dimensionierten Controller einzusetzen (größte Kosten) und der 
Performance des Codes die höchste Priorität einzuräumen. Timer und ISR's 
halte ich für Aufgaben frei die anders nicht zu lösen sind. Auch wenn 
der Algorithmus  von Herrn Dannegger programmiertechnisch exzellent ist, 
so geht  SW Entprellen,  auch wesentlich weniger codeintensiv und auch 
ohne Timer.

Was aber gar nicht in meinen Kopf hinein will, ist dass Du auf der einen 
Seite ein Kondensator und einen Wiederstand als zuviel zusätzliche 
Hardware ansiehst aber dann planst einen völlig Überflüssigen 
Schmitt-Trigger (AVR µC haben einen Schmitt-Trigger intern an den 
Eingängen)  nebst drei weiteren passiven Bauelementen zu Planen.

Du führst ja deine eigenen Argumente ad absurdum.

[Peter D. (peda)]

Stefan S. schrieb:
> if( get_key_short( 1<<KEY0 ))
>     LED_PORT ^= 1<<LED0;
>
>     if( get_key_long( 1<<KEY1 ))

get_key_short() und get_key_long() müssen immer je Taste aufgerufen 
werden.
Wenn man die Drückdauer unterscheidet, macht man das ja, um auch beide 
Ereignisse zu benutzen.
Die HW-Entprell-Päbste können das natürlich nicht erkennen und müssen 
ihren falschen Senf dazugeben.

[Bastler (Gast)]

@michi: wo wird da entprellt?

> Warum probierst du nicht einfach _delay_ms(50);
>
> if(taste high)
>{_delay_ms(x);
>  led_ein;
>}

[Stefan S. (sschultewolter)]

Bastler schrieb:
> @michi: wo wird da entprellt?
>
>> Warum probierst du nicht einfach _delay_ms(50);
>>
>> if(taste high)
>>{_delay_ms(x);
>>  led_ein;
>>}
Es funktioniert, weil das Prellen innerhalb von 50ms meistens 
abgeklungen ist. Das Programm macht in dem Zeitraum nichts und bekommt 
das Prellen nicht mit.

Peter Dannegger schrieb:
> Stefan S. schrieb:
>> if( get_key_short( 1<<KEY0 ))
>>     LED_PORT ^= 1<<LED0;
>>
>>     if( get_key_long( 1<<KEY1 ))
>
> get_key_short() und get_key_long() müssen immer je Taste aufgerufen
> werden.
> Wenn man die Drückdauer unterscheidet, macht man das ja, um auch beide
> Ereignisse zu benutzen.
> Die HW-Entprell-Päbste können das natürlich nicht erkennen und müssen
> ihren falschen Senf dazugeben.
Richtig, aber dann müsste auch folgendes funktionieren

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

Ich werde aber gleich mal versuchen es mit UART zu debuggen. Ob es 
verschwendung ist, einen Timer zu nehmen, oder nicht, hängt immer von 
der verwendeten Hardware ab. Ich brauche für das Projekt eine gewissen 
Menge an Flash des Attinys. 4KB wird hier für den Flash sehr sehr knapp. 
Daraufhin habe ich mich für einen Attiny85 entschieden (eigentlich 
sollte es ein AT841 werden, jedoch macht mir Farnell einen Strich durch 
die Rechnung).
Ich brauche keine große Anzahl an Timern. Lediglich diesen zum 
Entprellen, sowie den für die Zeit selber. Diesen könnte man sogar 
notfalls kombinieren da die doch ähnlich aufgebaut sind.

[Bastler (Gast)]

>@michi: wo wird da entprellt?

>> Warum probierst du nicht einfach _delay_ms(50);
>>
>> if(taste high)
>>{_delay_ms(x);
>>  led_ein;
>>}
> Es funktioniert ....

Entprellen bedeutet aber nicht beim ersten Muckser am Pin 50ms zu 
warten, sondern sicherzustellen, daß dies der Beginn eines "Gedrückt" 
war. Es fehlt da die erneute/wiederholt Abfrage des Eingangs. Einfach 
mal Dr. Google nach "Prellen Schalter" fragen, um zu erfahren was das 
identisch ist oder einfach hier den passenden Grundlagenartikel lesen.

[Teo D. (teoderix)]

Bastler schrieb:
> Entprellen bedeutet aber nicht beim ersten Muckser am Pin 50ms zu
> warten, sondern sicherzustellen, daß dies der Beginn eines "Gedrückt"
> war.

Kann man machen, muss man aber nicht.
Wenn man's nicht braucht und keine größeren Störungen hat o. befürchten 
muss, kann man das getrost auch weglassen.

[Bastler (Gast)]

Dann braucht man auch nicht warten, oder??

[Stefan S. (sschultewolter)]

Teo Derix schrieb:
> Bastler schrieb:
>> Entprellen bedeutet aber nicht beim ersten Muckser am Pin 50ms zu
>> warten, sondern sicherzustellen, daß dies der Beginn eines "Gedrückt"
>> war.
>
> Kann man machen, muss man aber nicht.
> Wenn man's nicht braucht und keine größeren Störungen hat o. befürchten
> muss, kann man das getrost auch weglassen.

Dann wurde aber im restlichen Code meist schon unnötig viele delays 
genutzt.

Nicht prellende Taster im Low-Budget Bereich sind mir nicht bekannt.

[Teo D. (teoderix)]

Bastler schrieb:
> Dann braucht man auch nicht warten, oder??

Hmm... Das war eindeutig tu dünn!

Etwas mehr angaschment bitte.

[Thomas H. (Firma: CIA) (apostel13)]

Peter Dannegger schrieb:
> Die HW-Entprell-Päbste können das natürlich nicht erkennen und müssen
> ihren falschen Senf dazugeben.

Selbstverständlich kann man auch noch von HW entprellten 
Eingangssignalen die Signalzeit bestimmen...Es gibt keinen falschen 
Senf, nur anderen...

[Stefan S. (sschultewolter)]

Wäre schön, wenn wir zum eigentlichen Thema noch einmal zurückkommen 
könnten.

Habe mir in der Zwischenzeit den Schaltung auf eine kleine 
Streifenrasterplatine aufgebaut, da die Taster nicht immer optimal im 
Steckbrett halten.

                                            5V
           .-----------------------o---------o
           |                       |
          .-.                     .-.
       4k7| |   PINB0    PINB1    | |4k7
          | |      o      o       | |
          '-'      |      |       '-'
  PIND2    |       |      |        |     PIND3
  o--------o       |      |        o---------o
           |       |      |        |
           |       |      |        |
        T  |       |      |        |  T
       --- |       |      |        | ---
     .-o o-'       |      |        '-o o--.
     |             |      |               |
     |  ___     LED|      | LED     ___   |
     o-|___|----|<-'      '->|-----|___|--o
     |  680                         680   |
     |                                    |GND
     '------------------------------------o--o
(created by AACircuit v1.28.6 beta 04/19/05 www.tech-chat.de)

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      [e-mail]                                  */
/*                                                                      */
/************************************************************************/

#define F_CPU 16000000UL

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

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

#define REPEAT_MASK     (1<<KEY1)       // 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            PIND2    // Arduino Pro Mini Pin 2
#define LED1            PIND3    // Arduino Pro Mini Pin 3

volatile uint8_t key_state;
volatile uint8_t key_press;
volatile uint8_t key_rpt;


ISR(TIMER0_OVF_vect)
{
  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;    // LOW ACTIVE
  //i = key_state ^ KEY_PIN;    // HIGH ACTIVE
  ct0 = ~( ct0 & i );
  ct1 = ct0 ^ (ct1 & i);
  i &= ct0 & ct1;
  key_state ^= i;
  key_press |= key_state & i;
  
  if( (key_state & REPEAT_MASK) == 0 )
  rpt = REPEAT_START;
  if( --rpt == 0 )
  {
    rpt = REPEAT_NEXT;
    key_rpt |= key_state & REPEAT_MASK;
  }
}

uint8_t get_key_press( uint8_t key_mask )
{
  cli();
  key_mask &= key_press;
  key_press ^= key_mask;
  sei();
  return key_mask;
}

uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();
  key_mask &= key_rpt;
  key_rpt ^= key_mask;
  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();
  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);
  
  KEY_DDR &= ~ALL_KEYS;
  KEY_PORT |= ALL_KEYS;
  
  TCCR0A = (1<<CS02)|(1<<CS00);
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);
  TIMSK0 |= 1<<TOIE0;
  
  sei();

  while(1)
  {
    if( get_key_short(1<<KEY0 ))
    LED_PORT ^= 1<<LED0;
    
    if( get_key_long( 1<<KEY0 ))
    LED_PORT ^= 1<<LED1;
  }
}

[chris (Gast)]

in deinem Schaltplan sind die LEDs und Taster vertauscht gegenüber den 
Angaben im Code.

[Stefan S. (sschultewolter)]

Den Schaltplan habe ich nach den Tests erstellt. Habe da die Pins 
vertauscht. Programm und Platine ist richtig.

[Teo D. (teoderix)]

TIP:
Wen Du schon solche Schwierigkeiten mit fremd Code hast, dann 
programmiere es halt selbst.
Der Lerneffekt ist unübertrefflich, wenn man was selber macht :)

[chris (Gast)]

du hast nirgends geschrieben, welchen Controller du benutzt (aber 
irgendwas von Arduino, also vermute ich Atmega328).

Ich habe das gerade kurz getestet auf einem Mega88 - die Timer-ISR wird 
garnicht aufgerufen. (einfach festzustellen mittels LED in der ISR 
anschalten).
Der Blick ins Datenblatt verrät auch sofort warum:
Der Prescaler wird beim Mega88 / 328 nicht in TCCR0A eingestellt, 
sondern in TCCR0B.
Dein Timer läuft also nicht.

nächstes Problem: du fragst "get_key_long(1<<KEY0)" ab. Um lange 
Tastendrücke feststellen zu können, muss KEY0 in der REPEAT_MASK 
eingetragen werden.

Nach diesen beiden Änderungen funktioniert der Code einwandfrei:

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      [e-mail]                                  */
/*                                                                      */
/************************************************************************/

#define F_CPU 8000000UL

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


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

// für langen Tastendruck muss die Taste hier eingetragen werden!
#define REPEAT_MASK     (1<<KEY0|1<<KEY1)       // 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            PIND2    // Arduino Pro Mini Pin 2
#define LED1            PIND3    // Arduino Pro Mini Pin 3

volatile uint8_t key_state;
volatile uint8_t key_press;
volatile uint8_t key_rpt;

ISR(TIMER0_OVF_vect)
{
  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;    // LOW ACTIVE
  //i = key_state ^ KEY_PIN;    // HIGH ACTIVE
  ct0 = ~( ct0 & i );
  ct1 = ct0 ^ (ct1 & i);
  i &= ct0 & ct1;
  key_state ^= i;
  key_press |= key_state & i;
  
  if( (key_state & REPEAT_MASK) == 0 )
  rpt = REPEAT_START;
  if( --rpt == 0 )
  {
    rpt = REPEAT_NEXT;
    key_rpt |= key_state & REPEAT_MASK;
  }
}

uint8_t get_key_press( uint8_t key_mask )
{
  cli();
  key_mask &= key_press;
  key_press ^= key_mask;
  sei();
  return key_mask;
}

uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();
  key_mask &= key_rpt;
  key_rpt ^= key_mask;
  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();
  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);
  
  KEY_DDR &= ~ALL_KEYS;
  KEY_PORT |= ALL_KEYS;
  
  // Prescaler ist nicht in TCCR0A, sondern in TCCR0B!
  TCCR0B = (1<<CS02)|(1<<CS00);
  
  
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);
  TIMSK0 |= 1<<TOIE0;
  
  sei();

  while(1)
  {
    if( get_key_short(1<<KEY0 ))
    LED_PORT ^= 1<<LED0;
    
    if( get_key_long( 1<<KEY0 ))
    LED_PORT ^= 1<<LED1;
  }
}

lg
Chris

[Stefan F. (Gast)]

Ja, das sehe ich auch so. Für Anfänger ist es einfacher und lehrreicher, 
keinen fremden Code einzusetzen.

Fremden Code zu analysieren (wenn er mal nicht wie erwartet 
funktioniert) ist erheblich schwieriger und eher etwas für 
Fortgeschrittene.

[chris (Gast)]

Nachtrag:
auf neueren AVRs (wie z.B. Mega88 / 328) kann man direkt Ausgangspins 
togglen, indem man ins PINx-Register schreibt. Das hat den Vorteil, dass 
es zum einen schneller geht und weniger Code erzeugt, zum anderen ist es 
aber auch atomar! D.h. es gibt keine Probleme, auch wenn du in 
Interrupts auf den gleichen Port schreibst.
Das sieht dann so aus:

#define LED_PIN    PIND

#define LED_DDR         DDRD
#define LED_PORT        PORTD
#define LED0            PIND2    // Arduino Pro Mini Pin 2
#define LED1            PIND3    // Arduino Pro Mini Pin 3

if( get_key_short(1<<KEY0 ))
LED_PIN = (1<<LED0);
    
if( get_key_long( 1<<KEY0 ))
LED_PIN = (1<<LED1);

[Stefan S. (sschultewolter)]

Einen eigenen Code habe ich bereits geschrieben, irgendwo oben, der auch 
soweit funktionierte.

Das es sich um einen Atmega328P handelt, bzw. Pro Mini, habe ich oben 
bereits geschrieben bzw. es im Code hinterlegt.

Nun geht es soweit, der einzige Fehler, den ich mehr oder weniger 
gemacht habe ist, dass ich hätte das B-Register wählen müssen anstatt 
des A-Registers.

Werde es nun wieder auf den Attiny85 portieren.

[Bastler (Gast)]

> Fremden Code zu analysieren (wenn er mal nicht wie erwartet
> funktioniert) ist erheblich schwieriger und eher etwas für
> Fortgeschrittene.

Aber man kann eben auch was dabei lernen ;-)
Fehler gezielt zu suchen (und dann auch zu beheben), ist das 
Eigentliche, was man können muß. Und da hilft nur Training!