µC schnell mit Eclipse und lahm mit AVR Studio?

[Alexander T. (xronin)]

Hallo zusammen,

dank Euch habe ich es endlich geschafft meinen ersten Controller zum 
Laufen zu bringen (ATTiny44 mit AVR Dragon).
Eine Sache finde ich allerdings äußerst merkwürdig.

Wenn ich das Programm (4 LEDs über Buttons steuern) mit Eclipse (WinAVR) 
kompiliere und starte, dann reagiert der Controller auf Tastendrücke 
ohne Verzögerung. Mache ich das ganze mit dem AVR Studio, dauert es 
mehrere Sekunden bis eine Reaktion erfolgt. Woran kann das liegen?? Der 
Quellcode ist der gleiche :(

Grüße,
Alex

[CC (Gast)]

F_CPU anders gesetzt?

[Alexander T. (xronin)]

Der Quellcode ist 1:1 der gleiche...

[Mirco (Gast)]

Die F_CPU wird im meistens im Makefile angegeben. Die sind auch gleich?
Bzw. du hast den richtigen Wert im AtmelStudio eingetragen?

[Test (Gast)]

Debug Mode im Studio aktiviert ? Fcpu in den projekteinstellungen falsch 
gesetzt (der Wert im quelltext ist egal)

[Sudo (Gast)]

Wie soll dir den jemand helfen wenn du weder Quellcode noch irgend was 
anderes lieferst.

[Alexander T. (xronin)]

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?

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

#ifndef F_CPU
#define F_CPU 20000000UL
#endif

#include <util/delay.h>



//////////////////////////////////////////////////////////////////////////
///////  Sleep function
//////////////////////////////////////////////////////////////////////////
void Sleep(unsigned int ms)
{
  for(; ms>0; ms--) _delay_ms(1);
}


//////////////////////////////////////////////////////////////////////////
///////  Debounce buttons
//////////////////////////////////////////////////////////////////////////
uint8_t Debounce( volatile uint8_t *port, uint8_t pin )
{
    if ( !(*port & (1 << pin)) )
    {
      _delay_ms(50);
      _delay_ms(50);
      if ( *port & (1 << pin) )
      {
        _delay_ms(50);
        _delay_ms(50);
        return 1;
      }
    }
    return 0;
}


int x = -1;

int main(void)
{
  //LEDs konfigurieren
  DDRA = (1 << PORTA0) | (1 << PORTA1) | (1 << PORTA2) | (1 << PORTA3);
  DDRB  = (1 << PORTB2);

  //Buttons konfigurieren
  DDRB  &= ~(1<<PORTB0);
  PORTB |= (1<<PORTB0);
  
  DDRB  &= ~(1<<PORTB1);
  PORTB |= (1<<PORTB1);

    while(1)
    {
      if(Debounce( &PINB, PINB0 ))
      {
        PORTA &= ~(1 << 0);
        PORTA &= ~(1 << 1);
        PORTA &= ~(1 << 2);
        PORTA &= ~(1 << 3);

        if (x > -2)
        {
          x--;
          if (x > -1)
          {
            PORTA |= (1 << x);
          }
        }
      }

      if(Debounce( &PINB, PINB1 ))
      {
        if (x < 4)
        {
          PORTA &= ~(1 << 0);
          PORTA &= ~(1 << 1);
          PORTA &= ~(1 << 2);
          PORTA &= ~(1 << 3);

          x++;
          if (x == 4)
          {
            PORTA |= (1 << 0);
            PORTA |= (1 << 1);
            PORTA |= (1 << 2);
            PORTA |= (1 << 3);
          }
          else if (x > -1)
          {
            PORTA |= (1 << x);
          }
        }
      }
    }
}

[Franz (Gast)]

Alexander Thies schrieb:
> AVR Studio

welche Version?

[BitKracherl (Gast)]

>Bei AVR Studio finde ich nirgendwo einen Eintrag?

#ifndef F_CPU
#define F_CPU 20000000UL
#endif

Nun, die Definition der Taktfrequenz kann auch mit dem Define im 
Quellcode geschehen. Das ist hier der Fall.

Mit Eclipse hast Du 1MHz eingestellt. Mit AVR mit 20MHz.

Das hat klarerweise Auswirkungen auf die delays.

[Hannes L. (hannes)]

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...

...

[Alexander T. (xronin)]

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?

[Robin F. (gehacktes)]

1MHz reichen vollkommen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

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...

[Oliver (Gast)]

Du solltest genau den Wert in der Software eintragen, mit der der 
Prozessor tatsächlich auch läuft.

Denn der F_CPU-Wert beeinflusst in keinster Weise die tatsächliche 
Taktfrequenz. Die hängt von den eingestellten Fuses und eines eventuell 
vorhandenen Quarz ab.

Oliver

[Maxx (Gast)]

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.

[Alexander T. (xronin)]

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

[Alexander T. (xronin)]

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?

[Falk B. (falk)]

Optimierung eingeschaltet?

[Mirco (Gast)]

Am besten ist du findest erstmal raus mit welcher Frequenz dein Chip 
läuft. Meistens sind die Grundeinstellungen 1Mhz oder 8Mhz, das steht im 
Datenblatt. Wenn du in den > 500 Seiten nicht suchen möchtest, ist es am 
einfachsten ein Blink-Programm zu schreiben und F_CPU zu variieren. Wenn 
die eingestellte Wartezeit mit der realen Zeit übereinstimmt hast du die 
richtige Frequenz gefunden.

[Alexander T. (xronin)]

Falk Brunner schrieb:
> Optimierung eingeschaltet?

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

[Karl H. (kbuchegg)]

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

#ifndef F_CPU
#define F_CPU 1000000UL
#endif

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

int main(void)
{
  DDRA = (1 << PORTA0);

  while(1)
  {
    PORTA |= ( 1 << PORTA0 );
    _delay_ms( 1000 );

    PORTA &= ~( 1 << PORTA0 );
    _delay_ms( 1000 );
  }
}

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.

[Alexander T. (xronin)]

Super. Vielen Dank!

[Karl H. (kbuchegg)]

-> 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.