Probleme beim Blinklicht mit Atmega8

[dex (Gast)]

ich versuche mich im moment an einem Blinklicht mit 3 LEDs, einem taster 
und einem Atmega8. für den Taster habe ich die Komfort-Entprellfunktion 
hier aus dem Forum genommen und an mein Code angepasst.
MEin Code sieht so aus:

#include <stdint.h>
#include <avr/io.h>
#include <avr/delay.h>
#include <avr/interrupt.h>
 
#ifndef F_CPU
#define F_CPU           1000000                   // processor clock frequency
#warning kein F_CPU definiert
#endif
 
#define KEY_DDR         DDRD
#define KEY_PORT        PORTD
#define KEY_PIN         PIND
#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         DDRB
#define LED_PORT        PORTB
#define LED0            1
#define LED1            2
#define LED2            3
 
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 )
{ volatile int counter=0;
  LED_PORT = 0x00;
  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
 
  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();
 
  while(1){
    if( get_key_short( 1<<KEY1 ))
      counter++;
    
 
    if( get_key_long( 1<<KEY1 ))
    counter=0;
   
   
   if(counter==0)
    LED_PORT = 0x00;
      
   
   if(counter==1)
    LED_PORT |= 1<<LED0;
    
    
      if(counter==2)
    LED_PORT |= (1<<LED0)| (1<<LED1);
    
    
      if(counter==3)
    LED_PORT |= (1<<LED0)| (1<<LED1) | (1<<LED2);
    _delay_ms(500);
    LED_PORT ^= (1<<LED0)| (1<<LED1) | (1<<LED2);
    
  
  }
}

zuerste hatte ich den selben Code ohne

_delay_ms(500);
LED_PORT ^= (1<<LED0)| (1<<LED1) | (1<<LED2);

und da hat es funktioniert wie er hofft, d.h zuerst sind alle LEDs aus, 
nach jedem tastendruck geht eine neue LED an und bei langem halten gehen 
sie wieder aus.

Wenn ich dann nur den delay reinmache passiert genau das selbe, jedoch 
gehen die LEDs verzögert an. das dürfte ja eigentlich nicht sein, da das 
delay nur in kraft tritt wenn der counter==3 ist und nicht schon bei 0,1 
und 2.

wenn ich dann noch zusätzlich

LED_PORT ^= (1<<LED0)| (1<<LED1) | (1<<LED2);

in die if(counter==3) einsetze dann macht die schaltung was komplett 
anderes als erwartet. geplant ist, dass beim dritten tastendruck alle 
LEDs einmal angehen und nach einer halben sekunde ausgehen.

was aber passiert ist, dass die LEDs zu beginn nur kurz aufflimmern, 
beim ersten Tastendruck leuchtet LED1 durchgehend und die anderen 
blinken. beim zweiten Tastendruck leuchten die ersten beiden durchgehenn 
und die letzte blinkt und beim letzten tastendruck leuchten alle 
durchgehend.

kann mir da einer helfen?

[Hubert G. (hubertg)]

Fehlen da vielleicht ein paar Klammern?  {  }

[dex (Gast)]

Hubert G. schrieb:
> Fehlen da vielleicht ein paar Klammern?  {  }

stimmt^^ und ich denke natürlich nicht an so etwas simples

passt jetzt soweit

Danke für die schnelle antwort

[dex (Gast)]

hab jetzt nochmal eine Frage zum selben Problem wenn ich jetzt bei einem 
counter möchte dass die LEDs blinken füge ich folgenden Code ein

      if(counter==3)
      {
          LED_PORT |= (1<<LED0)| (1<<LED1) | (1<<LED2);
        while (counter==3)
        {
          
          _delay_ms(500);
          LED_PORT ^= (1<<LED0)| (1<<LED1) | (1<<LED2);
          
        }
        
    
      }

allerdings reagiert mein Code ab diesem Zustand nicht mehr auf die 
Tasten

weder langes drücken noch ein kurzer druck bewirken irgendwas. Kennst 
jemand ne mögliche ursache dafür?

[Hubert G. (hubertg)]

dex schrieb:
> while (counter==3)

Warum das?

[J.-u. G. (juwe)]

dex schrieb:
> allerdings reagiert mein Code ab diesem Zustand nicht mehr auf die
> Tasten
>
> weder langes drücken noch ein kurzer druck bewirken irgendwas. Kennst
> jemand ne mögliche ursache dafür?

Ja. Die while-Schleife bricht nie ab, da "counter" immer 3 bleibt (wird 
ja nirgendwo geändert).

[dex (Gast)]

aber den änder ich doch durch den tastendruck wie bei den anderen 
abfragen auch. oder ist das etwas anderes? der tasten interrupt wird 
doch auch in der while schleife ausgeführt oder sehe ich das falsch?

[J.-u. G. (juwe)]

dex schrieb:
> aber den änder ich doch durch den tastendruck wie bei den anderen
> abfragen auch. oder ist das etwas anderes? der tasten interrupt wird
> doch auch in der while schleife ausgeführt oder sehe ich das falsch?

Die Variable "counter" wird doch in Deiner Interrupt-Routine gar nicht 
geändert. Das passiert bei Deinem Programm doch in der "main"-Funktion. 
Und an diese Stellen der "main"-Funktion kommst Du nicht mehr, da Du in 
der while-Schleife festhängst. In dieser Schleife wertest Du doch gar 
keine Tastendrücke mehr aus.