2xbit dividieren durch 2x8bit

[Philipp83]

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

[SprinterSB]

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)

[Philipp83]

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

[Philipp83]

STOP!!

Auch Georg darf nicht zu kurz kommen!!!!
Ist echt super nett das du mir die einzelnen Schritte ausführlich gezeigt hast!

[AlexAtRobo]

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

[AlexAtRobo]

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

[SprinterSB]

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.

; 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

Die Routine ist von avr-gcc.