Warteschleife für Atmega32 in Assembler

[A. B. (developer_x)]

Sehr geehrtes Forum,
ich habe einen Atmega32, an den extern ein 20 MhZ Quarz
angeschlossen ist. Ich habe die Fuses auf

H:0x99
L:0xDF

gestellt.

Nun habe ich versucht ein Warteschleifenprogramm mit
Assembler zu schreiben, sodass eine LED jede Sekunde an bzw.
ausgehen soll, aber egal was ich auch versuche, ich bekomm es einfach 
nicht hin. Kann mir jemand helfen und mir einen Code mit einer 
Warteroutine von 1s
geben, bzw. sagen was mit meinem nicht stimmt und diesen somit 
modifizieren?

Ich will nämlich wissen ob mein MC wirklich 20MHz hat oder nicht, er 
muss auch sehr präzise laufen, deshalb will ich diesen Test machen.

.include "m32def.inc"         ; Definitionsdatei für den Prozessortyp einbinden

.equ c1 = 49 ; Anzahl Durchläufe der Schleife

; 20.000.000 Hz 
; 1 Takt = 0.00000005
ldi r16, 0xFF       ; lade Arbeitsregister r16 mit der Konstanten 0xFF
out DDRB, r16       ; Inhalt von r16 ins IO-Register DDRB ausgeben
 
.def temp = r16
LDI  R16, low(RAMEND)
OUT  SPL, R16
LDI  R16, high(RAMEND)
OUT  SPH, R16

loop:  
  ldi r17, 0b00000001 ; 0b11111100 in r16 laden
  out PORTB, r17      ; r16 ins IO-Register PORTB ausgeben
  rcall wait

  ldi r17, 0b00000000 ; 0b11111100 in r16 laden
  out PORTB, r17      ; r16 ins IO-Register PORTB ausgeben
  rcall wait
  
rjmp loop


wait:
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
  rcall wait3
ret

wait1:
  ldi R18,c1 ; Lade Register mit Schleifenwert
  Loops: ; Schleifenbeginn
  dec R18 ; Registerwert um Eins verringern
  brne Loops ; wenn nicht Null dann Schleifenbeginn
ret

wait2:
  ldi R19,c1 ; Lade Register mit Schleifenwert
  Loopss: ; Schleifenbeginn
  rcall wait1
  dec R19 ; Registerwert um Eins verringern
  brne Loopss ; wenn nicht Null dann Schleifenbeginn
ret

wait3:
  ldi R20,c1 ; Lade Register mit Schleifenwert
  Loopsss: ; Schleifenbeginn
  rcall wait2
  dec R20 ; Registerwert um Eins verringern
  brne Loopsss ; wenn nicht Null dann Schleifenbeginn
ret

Ich bekomm es einfach nicht gebacken das Programm im AVR Studio zu 
simulieren, ob nach einem wait aufruf tatsächlich 20.000.000 Takte 
vergangen sind, da ja die Simulation sonst zu lange dauern würde, die 
LED blinkt aber nicht gerade im Sekundentakt.

Kann mir da vielleicht jemand einen Code geben bzw. diesen hier 
verbessern`?

Danke,
m.f.G.: Developer_X

[Peter II (Gast)]

K. R. schrieb:
> Ich bekomm es einfach nicht gebacken das Programm im AVR Studio zu
> simulieren, ob nach einem wait aufruf tatsächlich 20.000.000 Takte
> vergangen sind, da ja die Simulation sonst zu lange dauern würde

dann simuliere doch einfach nur den aufruf

rcall wait3


dann sollte doch machbar sein, dann kannst du diesen wert mal 10 
rechnen.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Oder du setzt auf die Portausgabe einen Breakpoint, merkst dir den Cycle 
Counter und startest mit 'run'. Nach dem Kaffeetrinken wird der 
Breakpoint irgendwann erreicht sein und du kannst die Cycles ablesen.

[Marc V. (Firma: Vescomp) (logarithmus)]

K. R. schrieb:
> Ich bekomm es einfach nicht gebacken das Programm im AVR Studio zu
> simulieren, ob nach einem wait aufruf tatsächlich 20.000.000 Takte
> vergangen sind, da ja die Simulation sonst zu lange dauern würde, die
> LED blinkt aber nicht gerade im Sekundentakt.

 Wie zu lange ?
 Ich glaube AVR Studio ist 8-10 mal langsamer.
 Wenn dir aber 8 Sec zu lang sind...

[Pink S. (pinkshell)]

Nach meinen überchlägigen Rechnungen wird die Wartezeit nicht 1 Sekunde 
sein.

Ein Loop in wait1 = 4 Zyklen
Wait1 komplett = 4 * 50 = 200 Zyklen.
Wait2 komplett = 200 * 50 = 10000 Zyklen.
Wait3 komplett = 10k * 50 = 500k Zyklen.
10 mal wait3 = 10 * 500k Zyklen = 5 Mio. Zyklen = 0,25 Sekunden @ 20MHz

Dazu der Schleifen Overhead, ein paar Prozent dazu. Von präzise kann 
keine Rede sin.

[A. B. (developer_x)]

So, ich habe das jetzt so eingestellt, bis wait3 genau 100.000 Zyklen 
dauert, jetzt funktioniert alles.

Das mit den 20 MHz stimmt, war mein erstes mal dass ich nen MC mit nem 
Quarz verbunden habe, danke :)

m.f.G.: DX

[Marc V. (Firma: Vescomp) (logarithmus)]

In deinem Code hat der Wait genau 3774547 Cycles gebraucht.
 Und es hat weniger als 4 Sec in AVR Studio gedauert...

[Blub (Gast)]

Wer bitte schön programmiert eine Warteschleife? Mach das mit Interrupt. 
Gewöhn dir so neun Kram gar nicht erst an, auch nicht nur zum Test.

[Thomas (kosmos)]

ich denke ich erkläre es so am schnellsten

a=0
b=0
c=0
Schleife1:
a=a-1
if a<>0 then goto Schleife1

Schleife2:
b=b-1
if b<>0 then goto Schleife1

Schleife3:
c=c-1
if c<>0 then goto Schleife1

so wird das ganze verschachtelt. Schleife1 läuft ja 255 mal durch x 255 
mal Schleife2 und dann nochmal 255 mal die Dritte Schleife.

Es gibt im Netzt eine Seite da gibts du die gewünschte Verzögerung ein 
und das Programm spuckt dir ein kleines Assemblerlisting aus.

Oder aber man nimmt einen Teiler mit passendem Teiler stellt ihn dann so 
ein das er nach einer gewünschten Zeit überläuft und einen Interrupt 
aufruft. Oder mittels Comparerregister. Dann kann man nämlich 
weiterarbeiten und hängt nicht in der Warteschleife fest.

[Yalu X. (yalu) (Moderator)]

Oder man schreibt ein kleines C-Programm:

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

int main(void) {
  DDRB = 0xff;
  for(;;) {
    PORTB ^= 0x01;
    _delay_ms(1000);
  }
}

Beim Kompilieren muss man die Option -DF_CPU=20000000 mitgeben. Die
ganze Rechenarbeit erledigt netterweise der Compiler.

[Moby A. (moby-project)]

Blub schrieb:
> Wer bitte schön programmiert eine Warteschleife? Mach das mit
> Interrupt.

Na das würd ich aber auch meinen! Profane Warteschleifen wie auch 
komplexe Statusmaschinerie realisiere ich standardmäßig so:
1) In jedem System ist ein allgemeiner Timerinterrupt installiert (läuft 
bei mir stets mit 200Hz), der für verschiedenste, regelmäßige Aufgaben 
im Hintergrund eingesetzt wird. Unter anderem für
2) Eine Anzahl benötigter 16-Bit Variablen wird mit jedem zweiten 
Timerinterrupt (also in Hundertstelsekunden) bis Null dekrementiert. 
Braucht ein (Haupt)Programmteil nun eine Warteschleife, lädt es eine 
solche Variable schlicht mit dem benötigten Wert. Das Programm macht nun 
andere Dinge und testet seine Variable zwischendurch auf Null... Soll 
bei Ablauf der Zeitspanne (bzw. einem Zwischenschritt) sofort etwas 
geschehen, kann man das natürlich auch gleich im Timerinterrupt machen.

[c-hater (Gast)]

Yalu X. schrieb:

> Die
> ganze Rechenarbeit erledigt netterweise der Compiler.

Das geht natürlich auch in Asm. Man muß sich eben nur mal hinsetzen und 
den entsprechenden Code schreiben (ist eigentlich viel mehr 
Macroprogrammierung als Assemblercode).

[Yalu X. (yalu) (Moderator)]

c-hater schrieb:
> Das geht natürlich auch in Asm.

Schon.

> Man muß sich eben nur mal hinsetzen und den entsprechenden Code
> schreiben

Eben.

Der TE wollte ja nur mal kurz prüfen, ob sein Controller mit externem
Quarz in der entsprechenden Konfiguration tatsächlich mit den erwarteten
20 MHz läuft. In solchen Fällen will man vor allem zwei Dinge:

  - minimalen Arbeitsaufwand

  - fehlerfreien Testcode

Das erreicht man am besten dadurch, dass man auf Code von anderen (hier
die _delay_ms-Funktion) zurückgreift, der bereits vielfach getestet und
einfach in der Handhabung ist.