Tasterentprellung + LED blinken (timer)

Dein Compiler kann nicht erkennen, dass die Änderung an der Variablen 
status in der ISR zum tragen kommt.
Für ihn sieht es so aus, als ob die ISR Funktion nie aufgerufen würde 
(der Compiler weiß nicht, dass die ISR automatisch aufgerufen wird)

Daher macht es für ihn auch keinen Sinn eine Variable zu beschreiben, 
die nirgendwo abgefragt wird. Wenn der Optimizer den ganzen Zugriff 
nicht überhaupt rauswirft, so versucht der Compiler zumindest die Zeit 
dafür einzusparen, indem er die Variable status in main() in einem 
Register hält. -> Die Änderung landet nie wirklich im Speicher.

volatile int status;

behebt dieses.

Ich hol das Programm mal hierher.
Das ist doch Unsinn, da immer auf eine externe Website gehen zu müssen, 
wenn man ein Programm studieren soll

1

#define F_CPU 1000000

2

3

#include <avr/io.h>

4

#include <avr/interrupt.h>

5

#include <util/delay.h>

6

7

int status = 0;

8

float count;

9

10

inline uint8_t debounce(volatile uint8_t *port, uint8_t pin) {

11

    if (! (*port & (1 << pin)))       {

12

        /* Pin wurde auf Masse gezogen, 100ms warten */

13

        _delay_ms(100);

14

        if ( ! (*port & (1 << pin)) ) {

15

        /* Anwender Zeit zum Loslassen des Tasters geben */

16

            _delay_ms(100);

17

            return 1;

18

        }

19

    }

20

    return 0;

21

}

22

23

int main(void) {

24

  // Prescaler = FCPU/1024

25

  TCCR0|=(1<<CS02)|(1<<CS00);

26

27

  //Enable Overflow Interrupt Enable

28

  TIMSK|=(1<<TOIE0);

29

30

  //Initialize Counter

31

  TCNT0=0;

32

33

  count=0;

34

35

  DDRD = 0xff;

36

  DDRA = 0x00;

37

  PORTA = 0xff;

38

39

  sei();

40

41

  while(1) {

42

    if(debounce(&PINA, PA0))

43

      status ^= 1;

44

  }

45

}

46

47

ISR(TIMER0_OVF_vect) {

48

  //This is the interrupt service routine for TIMER0 OVERFLOW Interrupt.

49

  //CPU automatically call this when TIMER0 overflows.

50

51

  count++;

52

  if((count == 4) && status) {

53

    PORTD ^= (1 << PD6);

54

    count=0;

55

  }

56

}

Also: count muss nicht volatile sein.
Es finden keine gmeinsamen Zugriffe aus main() und der ISR statt. Damit 
istr volatile kein Problem.

Aber float ist ein unglücklicher Datentyp für einen Zähler.
Laut Theorie kann zwar ein float bis zu einer bestimmten Zahl alle 
ganzen Zahlen exakt abbilden, ob das aber auch gilt, wenn gerechnet wird 
weiß ich nicht. Meine Hand drauf verwetten würde ich nicht.
Das mindeste was ich tun würde ist

   if((count >= 4) && status) {

Wenn bei der ganzen Inkrementiererei count zu 4.0000001 wird, dann 
funktioniert diese Variante immer noch, während der Vergleich auf exakt 
4 fehl schlägt.

status sollte auch ein 8-Bit Typ sein, also zb ein

unsigned char status

damit atomarer Zugriff garantiert ist.

Abgesehen davon ist mir nichts mehr aufgefallen

Marcel schrieb:

> Warum zum Teufel?! Es ist ein Integer, der kann doch genau 4 sein...

Können schon. Aber er muss nicht.

Wenn die ISR count hochzählt und status nicht gesetzt ist, dann wird 
count auch nie auf 0 zurückgesetzt sondern zählt hoch und zählt hoch 
....

1

ISR(TIMER0_OVF_vect)

2

{

3

  count++;

4

5

  if( count == 4 ) {

6

    count = 0;

7

8

    if( status ) {

9

      PORTD ^= (1 << PD6);

10

    }

11

  }

12

}