AVR while / do-while Schleife in Assembler

[O. A. (sokrates1989)]

Hallo,

ich habe ein paar Aufgaben vorliegen bei denen ich etwas Hilfe bräuchte.

und zwar möchte ich einen Zähler welcher von 1 bis 10 zählt 
programmieren.

ich habe bereits ein Programm gemacht welches dies macht. Allerdings 
weiß ich nicht ob mein Code einer do-while oder while Schleife 
entpsricht.

Wie würde in Assembler eines davon aussehen? Und entspricht meines einem 
davon?

Danke!

;+------------------------------------------------------------------------------
;| Titel : Aufgabe 1b
;| Prozessor : ATmega8
;| Frequenz : 3,6864 MHz
;| Datum :
;| Autor : Ostap Antonez,
;| Guppe :
;|
;| ...
;+------------------------------------------------------------------------------

.include "m8def.inc" 
.DEF zaehler = r16
.DEF speicher = r18

;-------------------------------------------------------------------------------
; Reset and Interruptvectoren ; VNr. Beschreibung
begin:
 
rjmp main ; 1 POWER ON RESET
reti ; 2 Int0-Interrupt
reti ; 3 Int1-Interrupt
reti ; 4 TC2 Compare Match
reti ; 5 TC2 Overflow
reti ; 6 TC1 Capture
reti ; 7 TC1 Compare Match A
reti ; 8 TC1 Compare Match B
reti ; 9 TC1 Overflow
reti ; 10 TC0 Overflow
reti ; 11 SPI, STC Serial Transfer Complete
reti ; 12 UART Rx Complete
reti ; 13 UART Data Register Empty
reti ; 14 UART Tx Complete
reti ; 15 ADC Conversion Complete
reti ; 16 EEPROM Ready
reti ; 17 Analog Comparator
reti ; 18 TWI (I²C) Serial Interface
reti ; 19 Store Program Memory Ready
;--------------------------------------------------------------------------------

; Aufwärtszähler von 1 bis 10
; Die Werte sollen in r18= Speicher gespeichert werden.
;--------------------------------------------------------------------------------
; Start

main: 

ldi r16 , LOW(RAMEND)   ; Init Stackpointer Low
out SPL , r16       ; init Stack
ldi r16 , HIGH(RAMEND)   ; init Stackpointer High
out SPH , r16       ; init Stack

ldi zaehler, 0x01    ; setze Zähler auf den Wert "1"

mainloop:

inc zaehler        ; erhöhe den Wert im Zähler um den Wert "1"

cpi zaehler, 10      ; vergleiche den Zähler mit dem Wert "10", setze Z-Flag

mov speicher, zaehler  ; bringe den Wert ins Register 18

breq naechste_zaehlung  ; springe zur nächsten Zählung wenn der Wert "10" erreicht ist.

rjmp mainloop      ; kehre zurück zur mainloop



naechste_zaehlung: 

ldi zaehler, 0x01    ; der Zähler wird wieder auf "1" gesetzt

rjmp mainloop      ; kehre zurück zur mainloop

[Einer K. (Gast)]

Ich sehe gar nicht, wo deine Schleife anfängt und aufhört!

Wenigstens so Kommentare/Lables wie:
1. Schleifenkopf
2. Schleifenkörper
3. Schleifenfuß

Würde ich erwarten.
Klar abgegrenzt.
Und wenn dir dann noch klar ist, was der Unterschied zwischen while und 
do-while sein könnte, dann hast du schon fast 100 Punkte

(bin jetzt aber nicht der Assembler Spezi, dass ich dir das aus dem 
Ärmel schütteln könnte)

[guest (Gast)]

Asssembler ist zwar nicht so ganz mein Fall, aber das sieht rudimentär 
nach Variante b) aus, zählt allerdings von 2 bis 10

[Markus F. (mfro)]

was könnte denn wohl der Unterschied zwischen "do ... while (Bedingung)" 
und "while (Bedingung) do" sein?

Hinweis: in altmodischem Informatiker-Deutsch heisst das "nicht 
abweisende" beziehungsweise "abweisende" Schleife.

[derjaeger (Gast)]

oder kopfschleife und fußschleife

[Michael U. (amiga)]

Hallo,

zum etwas chaotischen Ablauf wurde ja schon was geschrieben.
Ansonste ist es meiner Meinung nach eine Do-While weil die Schleife 
mindestens einmal durchlaufen wird. Bei einer While müßte die Abfrage 
auf den Endwert am Anfang stehen, so daß der Inhalt der Schleife 
garnicht ausgeführt wird wenn die Bedingung nicht erfüllt ist.

mainloop:

ldi zaehler, 0x01    ; setze Zähler auf den Wert "1"

while_begin:         ; Beginn Schleife
cpi zaehler, 10      ; Bedingung abfragen
breq weiter          ; wenn erfüllt raus aus der Schleife

inc zaehler
mov speicher, zaehler
rjmp while_begin     ; Ende Schleife  

weiter:              ; Programm hinter der While Schleife fortsetzen  

rjmp mainloop        ; hier nur kehre zurück zur mainloop und zähle neu

Gruß aus Berlin
Michael

[c-hater (Gast)]

O. A. schrieb:

> Allerdings
> weiß ich nicht ob mein Code einer do-while oder while Schleife
> entpsricht.

Dann sind dir zwei Sachen nicht klar:
1) Was der springende Punkt beim Unterschied zwischen "while" und "do 
while" ist
2) Was dein Programm eigenlich tut.

Nicht gut...

> Wie würde in Assembler eines davon aussehen? Und entspricht meines einem
> davon?

Ja, das ist eine Schleife vom Typ "do while".

Übrigens: der entscheidende Trick, mit dem man in Assembler am 
effizientesten aus "do while" ein "while" macht, ist direkt suggestiv in 
der Aufgabenstellung formuliert. Man braucht die eigentlich bloß 
verstehend zu lesen und stellt fest, dass die Aufgabenstellung den 
wesentlichen Punkt der Lösung bereits selber liefert...

Wenn man nun noch sinnvolle Labels (im Sinne der Aufgabenstellung) 
verwendet, sieht dein Programm derzeit prinzipiell so aus (den mit der 
Schleife nicht direkt zusammenhängenden Kram habe ich weggelassen):

init:
 ldi zaehler, 0x01    ; setze Zähler auf den Wert "1"

do:
 inc zaehler        ; erhöhe den Wert im Zähler um den Wert "1"

 cpi zaehler, 10      ; vergleiche den Zähler mit dem Wert "10", setze Z-Flag

 mov speicher, zaehler  ; bringe den Wert ins Register 18

while:
 breq reinit  ; springe zur nächsten Zählung wenn der Wert "10"  erreicht ist.
 rjmp do      ; kehre zurück zur mainloop

reinit:
 ldi zaehler, 0x01    ; der Zähler wird wieder auf "1" gesetzt
 rjmp do      ; kehre zurück zur mainloop

Das würde man aus Gründen der Effizienz, Korrektheit und Lesbarkeit 
erstmal so umformulieren:

init:
 ldi zaehler, 0x01    ; setze Zähler auf den Wert "1"

do:
 mov speicher, zaehler  ; bringe den Wert ins Register 18
 inc zaehler        ; erhöhe den Wert im Zähler um den Wert "1"

while:
 cpi zaehler, 10      ; vergleiche den Zähler mit dem Wert "10", setze Z-Flag
 brne do  ; springe zur Schleife, wenn der Wert "10"  nicht erreicht ist.
 rjmp init     ; reinitialisiere die Schleife

Wie man nun mit einer einzigen zusätzlichen Zeile eine Schleife vom Typ 
"while" daraus macht, überlasse ich dir. Beachte die Aufgabenstellung, 
da steht das, wie gesagt, schon drin.

[guest (Gast)]

c-hater schrieb:
> Korrektheit

Naja.
Während sein Beispiel von 2 bis 10 zählt, zählt Deines von 1 bis 9.
Soviel zum Thema Korrektheit.

[Ralf (Gast)]

Und schon wieder wurden die Hausaufgaben von jemand anderes gemacht!

[Egon N. (egon2321)]

Ralf schrieb:
> Und schon wieder wurden die Hausaufgaben von jemand anderes
> gemacht!

Naja, wer programmiert ernsthaft noch Schleifen direkt in ASM?!

[S. R. (svenska)]

Egon N. schrieb:
> Naja, wer programmiert ernsthaft noch Schleifen direkt in ASM?!

Ich. Davon abgesehen geht es bei Hausaufgaben nicht um sinnvollen 
Produktivcode im Unternehmen, sondern ums Lernen.

[Norbert T. (atos)]

Ich ebenfalls.

[guest...Rainer (Gast)]

Egon N. schrieb:
> Naja, wer programmiert ernsthaft noch Schleifen direkt in ASM?!

Ich auch :-)

[Thomas F. (igel)]

Egon N. schrieb:
> Naja, wer programmiert ernsthaft noch Schleifen direkt in ASM?

Und ich.

[Dergute W. (derguteweka)]

Moin,

Ja, ich auch. Aber nur wenns schnell gehen muss. Und dann mach' ich auch 
noch gleich ein loop-unrolling ;-)

inc zaehler
inc zaehler
inc zaehler
inc zaehler
inc zaehler
inc zaehler
inc zaehler
inc zaehler
inc zaehler

Gruss
WK

[Heinz V. (heinz_v)]

me2

[O. A. (sokrates1989)]

Danke soweit.!

[Arno (Gast)]

Wenn der Lehrer die Aufgabe schon so seltsam formuliert...

[quote]Es sollen die Zahlen von 1 bis 10 programmiert werden[/quote]

...ist es kein Wunder, dass die Ergebnisse seiner Schüler auch nicht 
weniger chaotisch werden.

MfG, Arno