Druckbare Version
Hast zwar recht, aber das war nicht der Fehler :-(
Hmm,
Naja..... vielleicht bekomme ich ja auch nochmal einen Geistesblitz.
Vielleicht sollte ich auch einfach bei meinen Sprachen Basic,C bleiben.
War zwar fest entschlossen was Assembler angeht, was auch programmmäßig
alles gut klappt, aber diese rechnerei kapiere ich einfach irgendwie nicht.
mfg, Philipp
Code:R = 11101010 01100000 = 60000
------------------------- Q = 0
N = 01001110 00100000 = 20000
N schieben, so daß das höchste Bit stimmt:
R = 11101010 01100000
----------------- Q = 0
2*N = 10011100 01000000
abziehen, da kleinergleich
R = 01001110 00100000
----------------- Q = 10
2*N = 10011100 01000000
Nenner nach rechts schieben
R = 01001110 00100000
------------------ Q = 10
1*N = 01001110 001000000
abziehen, da kleinergleich
R = 00000000 000000000
------------------ Q = 11
1*N = 01001110 001000000
Fertig, da Rest=0 bzw Nenner am rechten Anschlag
Q = 11 (=3)
Hallo liebe Leute
Ich habe zwar jetzt verstanden wie das ganze auf dem papier funktioniert,
nur das in assembler richtig umzusetzen... Naja :-)
Auf alle fälle VIELEN DANK an alle! Aber auch besonders an Alex, der ein so gut funktionierendes proggi gepostet hat.
Das zu verstehen dauert zwar glaub ich noch etwas (avrstudio zeigt die register ja leider nicht in binär an).
Eigentlich kann ich das nicht sehr gut mit mir vereinbaren etwas in mein Programm aufzunehmen was ich nicht 100% verstehe,
Aber nun gut.
Sagt mal, wie lange programmiert ihr schon in assembler das euch sowas keine Probleme macht?
mfg, philipp
STOP!!
Auch Georg darf nicht zu kurz kommen!!!!
Ist echt super nett das du mir die einzelnen Schritte ausführlich gezeigt hast!
Hallo Phillipp,
du kannst im AVR Studio auch die Register Binär anzeigen. Dazu gibt es ein eigenes Fenster zum Registeranzeigen. Dass kannst du auch auf Binär umstellen, dann ist es schöner zum nachvollziehen. Mußt mal schauen, ich hab jetzt auf diesem rechner grad kein Studio drauf. Geht aber auf jeden Fall.
lg
Alex
Noch was:
cp rd1uh, rd2h
brcs div3
cp rd1ul,rd2l ; Divisionsergebnis 1 oder 0?
brcs div3 ; Überspringe Subtraktion, wenn kleiner
Und hier ist noch ein Fehler drinnen. Es wird bei der ersten Abfrage nur verzweigt, wenn rd1uh < rd2h ist. Wenn beide gleich groß sind, ist es auch noch ok. Aber wenn rd2h > rd1uh ist, muß sofort verzweigt werden.
Der richtige Vergleich ist von Georg geschrieben worden.
cp rd1ul, rd2l
cpc rd1uh, rd2h
Wie lange schon Assembler? Naja, am AVR erst 2 Jahre - aber es ist einfach geil, wenn man über die Serielle Schnittstelle X/Y/Z x 2Bytes übergibt, dann die unterschiedlichen Steigungen der Geraden im AVR Berechnet, und 3 Schrittmotoren zeitgleich unterschiedlich schnell ansteuert dass alle Zeitgleich am Zielpunkt ankommen. Und das mit weniger als 600 Zeilen Assembler. Und es ginge noch mit weniger... Beschleunigungsrampen und Bremsrampen sind auch noch drinnen ;-). Und dem Ding ist immer noch langweilig...
Was nicht heißt das es nicht mit Winavr C auch genauso gegangen wäre.
Übrigens war die Division auch für mich am Anfang mühsam, aber mit der Zeit durchschaut man es dann schon.
lg
Alex
Hier noch eine sehr effiziente Divisionsroutine für zwei 16-Bit-Werte.
Sie braucht nur 7 Register und 18 Instruktionen.
Ausserdem berechnet sie auch den Rest der Division.
Die Routine ist von avr-gcc.Code:; Input
; r25:r24 = Zähler
; r23:r22 = Nenner
; Output
; r25:r24 = Quotient
; r27:r26 = Rest
; Verwendete Register:
; r21-r27
div16:
; Ergebnis auf 0, Carry löschen
clr r26
sub r27, r27
; 17 Bits werden rotiert (16 Bits-Wert und Carry)
ldi r21, 17
rjmp div16_start
div16_loop:
; Zähler nach links rotieren (Bits kommen aus r25:r24)
rol r26
rol r27
; Vergleich gegen Nenner
cp r26, r22
cpc r27, r23
brcs div16_start
; Abziehen, wenn kleinergleich
sub r26, r22
sbc r27, r23
div16_start:
; Hier entsteht das Komplement des Ergebnisses
; C=0: es wurde abgezogen
; C=1: es wirde nicht abgezogen
rol r24
rol r25
dec r21
brne div16_loop
; fertig
; Bits des Ergebnis müssen noch invertiert werden
com r24
com r25
ret