µC schnell mit Eclipse und lahm mit AVR Studio?

Der Quellcode ist 1:1 der gleiche...

Entschuldigung, hier ist schonmal der Quellcode. Ich erstelle das 
Projekt in der Release Version. Bei Eclipse ist die Frequenz in den 
Projekteinstellungen mit 1Mhz (1000000) angegeben. Bei AVR Studio finde 
ich nirgendwo einen Eintrag?

1

#include <avr/io.h>

2

#include <avr/interrupt.h>

3

4

#ifndef F_CPU

5

#define F_CPU 20000000UL

6

#endif

7

8

#include <util/delay.h>

9

10

11

12

//////////////////////////////////////////////////////////////////////////

13

///////  Sleep function

14

//////////////////////////////////////////////////////////////////////////

15

void Sleep(unsigned int ms)

16

{

17

  for(; ms>0; ms--) _delay_ms(1);

18

}

19

20

21

//////////////////////////////////////////////////////////////////////////

22

///////  Debounce buttons

23

//////////////////////////////////////////////////////////////////////////

24

uint8_t Debounce( volatile uint8_t *port, uint8_t pin )

25

{

26

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

27

    {

28

      _delay_ms(50);

29

      _delay_ms(50);

30

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

31

      {

32

        _delay_ms(50);

33

        _delay_ms(50);

34

        return 1;

35

      }

36

    }

37

    return 0;

38

}

39

40

41

int x = -1;

42

43

int main(void)

44

{

45

  //LEDs konfigurieren

46

  DDRA = (1 << PORTA0) | (1 << PORTA1) | (1 << PORTA2) | (1 << PORTA3);

47

  DDRB  = (1 << PORTB2);

48

49

  //Buttons konfigurieren

50

  DDRB  &= ~(1<<PORTB0);

51

  PORTB |= (1<<PORTB0);

52

53

  DDRB  &= ~(1<<PORTB1);

54

  PORTB |= (1<<PORTB1);

55

56

    while(1)

57

    {

58

      if(Debounce( &PINB, PINB0 ))

59

      {

60

        PORTA &= ~(1 << 0);

61

        PORTA &= ~(1 << 1);

62

        PORTA &= ~(1 << 2);

63

        PORTA &= ~(1 << 3);

64

65

        if (x > -2)

66

        {

67

          x--;

68

          if (x > -1)

69

          {

70

            PORTA |= (1 << x);

71

          }

72

        }

73

      }

74

75

      if(Debounce( &PINB, PINB1 ))

76

      {

77

        if (x < 4)

78

        {

79

          PORTA &= ~(1 << 0);

80

          PORTA &= ~(1 << 1);

81

          PORTA &= ~(1 << 2);

82

          PORTA &= ~(1 << 3);

83

84

          x++;

85

          if (x == 4)

86

          {

87

            PORTA |= (1 << 0);

88

            PORTA |= (1 << 1);

89

            PORTA |= (1 << 2);

90

            PORTA |= (1 << 3);

91

          }

92

          else if (x > -1)

93

          {

94

            PORTA |= (1 << x);

95

          }

96

        }

97

      }

98

    }

99

}

Alexander Thies schrieb:
> Bei AVR Studio finde
> ich nirgendwo einen Eintrag?

Und was ist das?

> #ifndef F_CPU
> #define F_CPU 20000000UL

20 MHz, wenn die CPU real mit 1 MHz löwt, dann dauern alle Delays 20 mal 
so lange...

...

Es ist AVR Studio 6.1. Im Datenblatt stand, dass sie mit 20Mhz laufen 
kann. Welchen Wert sollte ich den benutzen, um den µC  nicht zu 
überfordern?

1MHz reichen vollkommen.

Alexander Thies schrieb:
> uint8_t Debounce(...)
Welch sinnlose Verschwendung von Rechenzeit...

> Bei Eclipse ist die Frequenz in den Projekteinstellungen mit 1Mhz
> (1000000) angegeben.
> ...
> #define F_CPU 20000000UL
Voll konsistent, dass du im Quelltext 20MHz angibst  :-o
BTW: welchen Takt hat dein uC?
Das sollte überall der selbe Wert sein...

Lothar Miller schrieb:
> Alexander Thies schrieb:
>> uint8_t Debounce(...)
> Welch sinnlose Verschwendung von Rechenzeit...
Ich weiß es leider nicht besser...Tipps?

> Alexander Thies schrieb:
>> Wenn ich das Programm (4 LEDs über Buttons steuern) mit Eclipse (WinAVR)
>> kompiliere und starte,
> Worauf startest du das Programm?
ATTiny44A

> Alexander Thies schrieb:
>> Bei Eclipse ist die Frequenz in den Projekteinstellungen mit 1Mhz
>> (1000000) angegeben.
>> ...
>> #define F_CPU 20000000UL
> Voll konsistent, dass du im Quelltext 20MHz angibst  :-o
> BTW: welchen Takt hat dein uC?
> Das sollte überall der selbe Wert sein...
Die Einstellungen bei Eclipse stammen nicht von mir, die habe ich gerade 
eben gefunden. Ich habe lediglich die F_CPU Definition vorgenommen

Maxx schrieb:
> Alexander Thies schrieb:
>> Es ist AVR Studio 6.1. Im Datenblatt stand, dass sie mit 20Mhz laufen
>> kann. Welchen Wert sollte ich den benutzen, um den µC  nicht zu
>> überfordern?
>
> F_CPU bestimmt NICHT wie schnell der uC läuft
> F_CPU gibt deinem Programm einen hinweis wie schnell du meinst, dass der
> uC läuft.
>
> Die tatsächliche Geschwindigkeit hängt von deinen Fuses ab (intern,
> extern, Quarz, Oszillator, CLKDIV8, etc) und je nachdem von deiner
> Beschaltung.

Also wenn der interne Oszillator mit 8Mhz läuft, und durch das Fusebit 
der Takt nochmal durch 8 geteilt wird, ist dann 1Mhz der richtige Takt 
für den µC?

Optimierung eingeschaltet?

Falk Brunner schrieb:
> Optimierung eingeschaltet?

Optmierung steht auf O1..nachdem ich F_CPU auf 1Mhz gesetzt habe, läuft 
es besser :) Danke.

Alexander Thies schrieb:

> Also wenn der interne Oszillator mit 8Mhz läuft, und durch das Fusebit
> der Takt nochmal durch 8 geteilt wird, ist dann 1Mhz der richtige Takt
> für den µC?

Ja, ist er.

Du kannst das auch ganz leicht testen

1

#ifndef F_CPU

2

#define F_CPU 1000000UL

3

#endif

4

5

#include <avr/io.h>

6

#include <util/delay.h>

7

8

int main(void)

9

{

10

  DDRA = (1 << PORTA0);

11

12

  while(1)

13

  {

14

    PORTA |= ( 1 << PORTA0 );

15

    _delay_ms( 1000 );

16

17

    PORTA &= ~( 1 << PORTA0 );

18

    _delay_ms( 1000 );

19

  }

20

}

Wenn der Wert für F_CPU korrekt ist, UND NUR DANN, dann blinkt deine LED 
mit 1 Sekunde an/aus. Sprich dann sind die 1000 Millisekunden in 
_delay_ms auch wirklich 1000 Millisekunden (1 Sekunde).

Würde dein µC tatsächlich 8 mal schneller laufen (mit 8Mhz) dann ist 
auch das Blinken 8 mal schneller. Das siehst du mit freiem Auge. Damit 
die 1000 Millisekunden wieder real 1 Sekunde dauern, müsstest du dann 
F_CPU auf 8000000 stellen, damit es wieder der Realität der Taktfrequenz 
deines µC entspricht. Stellst du umgekehrt die F_CPU auf 8000000, taktet 
der µC aber tatsächlich nur mit 1Mhz, dann ist das Blinken 8 mal 
langsamer. Anstatt alle 1 Sekunden, dauert es 8 Sekunden bis die LED aus 
geht bzw. wieder eingeschaltet wird. Und auch das sieht man mit freiem 
Auge.

Nur dann, wenn F_CPU tatsächlich mit dem übereinstimmt, wie schnell der 
µC wirklich getaktet wird, dann stimmen die Verzögerungen, die _delay_ms 
anhand des Wertes von F_CPU für eine Millisekunde berechnet auch 
(einigermassen) mit der Realität einer Millisekunde überein.

Super. Vielen Dank!

-> Es ist immer gut, wenn man auch versteht, was die einzelnen Dinge in 
einem Programm tun und wie sie zusammenhängen. Genau aus dem Grund sind 
die ersten Übungen mit dem µC diverse LED Blink Programme. Man kann mit 
ihnen viel mehr lernen als das da einfach nur eine LED blinkt. Ganz im 
Gegenteil, dass die LED was macht, ist eine nette Zugabe. In 
Wirklichkeit geht es bei all diesen Übungen um ganz andere Dinge, die 
LED (oder LEDs) sind nur der Aufhänger, damit man Spass am 
Experimentieren hat und sich was an der Schaltung tut.