Banale Assembler-Schleifenfrage

Klaus schrieb:
   > x ist ein zwei Registern, aber maximal 512 gross.

Was soll das heißen?

Dass eine so grosse Zahl nicht in einem Register Platz hat und deshalb 
auf 2 aufgeteilt ist zum Beispiel:
ldi r20, high(x)
ldi r21, low(x)

Kleines Beispiel für 'ne Pause:

PAUSE:  ldi  PZEIT1,255
  ldi  PZEIT2,1
P_WAIT:  dec  PZEIT1
  brne  P_WAIT
  ldi  PZEIT1,255
  dec  PZEIT2
  brne  P_WAIT
  ret

Sollte von 512 'runterzählen.

Hmm.. sehr unübersichtlich.

Schleife:   ldi  X_low,255
            ldi  X_high,1

>hier Code einfügen<

WAIT:       dec  X_low
            brne WAIT
            ldi  X_low,255
            dec  X_high
            brne WAIT
ret

müsste besser sein.

Ups.. X_high muss natürlich mit 2 initialisiert werden!

>Sollte von 512 'runterzählen.
Zählt aber von 511 runter...

Das 2. ldi PZEIT1,255 müsste man sich aufgrund des begrenzten 
Zahlenraums sparen können.
(Bin aber niocht ganz so asmbewandert...)

OK, das ist ziemlich kompakt, aber wenn ich zur initialisierung
ldi X_high, 0
habe, dann funktionierts nicht? Oder täusche ich mich? Dann zieht er 
eins ab, obwohl er schon null ist??

>Zählt aber von 511 runter...

Die komplette Schleife zählt von 512 'runter. Evtl. 'ne kleine 
Zeitüberschneidung beim Posten ?!

111111111b ist für mich 511 dezimal, oder?

Sie wird 512 Mal durchlaufen...

Hat wohl keiner bemerkt:

Schleife:   ldi  X_low,255
            ldi  X_high,1
WAIT:

>hier Code einfügen<

            dec  X_low
            brne WAIT
            ldi  X_low,255
            dec  X_high
            brne WAIT
ret

So muss es aussehen.
Kannst auch von 0 abwärtszählen, dann wird das 'N'-Flag gesetzt. Wenn 
das nicht stört zählt er halt von 256 'runter.

Wenn ich obigen code simuliere, dann erhalte ich wie bereits vermutet 
komische ergebnisse, die schleife wird nicht mit jedem wert <512 korrekt 
oft mal durchlaufen, anscheinend geht es doch nicht so einfach...
zum Beipiel mit 256 also x_low=0 und x_high=1, dann wird die Schleife 
511 mal durchlaufen. Man muss (wie ich bereits befürchtet habe) auch auf 
null testen bevor man abzählen kann :(

Hmm.. X_high sollte 2 sein, dann sollte die X_low-Schleife 2x 
'runtergezählt werden, sprich: 2x256=512. Hatte vergessen die X_high auf 
2 zu ändern, sorry!

wenn ich 255 wie folgt initialisiere:
x_low = 255
und x_high = 1
dann gehts

wenn ich für 256 folgendes eingebe:
x_low = 0
x_high = 2
dann machts die schleife eben 511 mal

deshalb wäre es irgendwie von Vorteil, wenn es eine Möglichkeit gibt die 
auch  geht...
An so einem einfachen Ding verzweifle ich noch

>wenn ich 255 wie folgt initialisiere:
x_low = 255 und x_high = 1
dann gehts

Na, ist doch auch richtig. In Assembler und C wird ab 0 gezählt, also 
0..255 sind 256 Schritte. Sobald beim Abwärtszählen von 255 die 0 
erreicht wird (und das Zero-Flag gesetzt wird) sind 256 Schritte 
durchlaufen. Bau' die Schleife so auf und es funktioniert!

Sorry nochmal, X_high muss 2 sein, sonst geht's nicht. Ansonsten ist die 
Schleife so korrekt, läuft 512 Schritte durch.

ich glaub ich bin zu blöd,
bei x_low = 0
und x_high = 2
bekomme ich 511 durchläufe

Danke Karl, so kam ich der Sache auf die Spur, man musste aber noch 
überprüfen ob denn von high nicht abgezogen wird obwohl schon null, 
folgendes ist entstanden:
ldi  X_low,255
ldi  X_high,0
WAIT:

//>hier Code einfügen<

            dec  X_low
            brne WAIT
      tst X_high
      breq finito
            dec  X_high
            rjmp WAIT
finito:

wer was einfachere kennt, bei dem man die Zahlen einsetzen kann und es 
läuft dann auch so viel mal, der möge sich melden....

Wieso einfach wenns auch kompliziert geht?
Danke vielmals