  INFO - FAQ - CC2-Forum - CCPro-Forum |
|
||
|
Hallo OMACRO-Freunde, im Forum hier habe ich keinen Hinweis gefunden, wie eine Lösung für die Aufgabe "Quadratwurzel von 32 Bit Zahl" funktioniert. Im O-Micro Download Bereich hat Dietmar Harlos folgendes eingestellt "Grundrechenarten in 32 Bit" Dieses Beispielprogramm demonstriert, wie sich 32-Bit-Arithmetik (+ ; - ; ./. ; * ) auf der Open-Micro, Open-Mini und Open-Midi realisieren läßt. Die Lösung im Assembler Code erstellt, benutze ich bereits derzeit für mein Projekt. Für etwas genauere Entfernungsbestimmungen bräuchte ich die Quadratwurzel von einer 7 stelligen Zahl. Mit dem Wertebereich der OMACRO von -32768 bis 32767 könnte ich zwar auch rechnen, das wäre aber etwas ungenauer. Deshalb suche ich nach der Lösung der Aufgabe mit Quadratwurzel von einer 32 Bit Zahl Im Forum http://www.mikrocontroller.net/topic/139416 habe ich eine Lösung gefunden für AVR uController. Angeblich stammt diese aus einer APP Note von Atmel; siehe dazu unten den AVR Assembler Code. Nun habe ich versucht den AVR Assembler Code dieses Beispielprogramms auf OMACRO Assembler umzusetzen und diese Subroutine für SQRT_32 im Beispielprogramm von Dietmar Harlos "Grundrechenarten in 32 Bit" eingebunden. Um die AVR Assembler Befehle zu verstehen, habe ich im AVR Studio die Help Funktion benutzt u. die Befehle verglichen mit den 68HC908 uController Assembler Befehlen. Berücksichtigt habe ich auch den unterschiedlichen Aufbau der uController. Der AVR hat 32 Register, mit denen man viele Rechenoperationen durchführen kann, während man bei OMACRO/68HC908 dafür z.T. das Akkumulator u. Indexregister sowie die Variablen Register benutzt. Trotzdem ich mir viel Mühe gemacht habe, reichen leider meine Assemblerkenntnisse nicht aus, um die Aufgabe komplett zu lösen. In AVR Assembler gibt es doch einige Befehle, für die ich in OMACRO/68HC908 Assembler keinen Workaround gefunden habe; z.B. sbrs R0,5 'skip if bit 5 in register R0 is set: sbrs R0,5 ; Skip if 17 bits developed oder cpc ' compare with carry cpc R22,R16 Auch bei anderen Befehlen war ich mir nicht sicher, ob ich die dafür passenden OMACRO/68HC908 Assembler Befehle benutzt habe. Wenn ich das Beispielprogramm mit dem Basic Compiler compiliere, dann kommen zwar keine Fehlermeldungen mehr. Das Programm lässt sich auch laden und ausführen. Es bleibt dann aber in dem, von mir erstellten Assemblerteil hängen. Vielleicht findet sich jemand im Forum, der sich das Beispielprogramm ansieht und eine Lösung findet! Das Beispielprogramm ist unten angehängt. Vielen Dank im voraus Joe ;---------------hier der AVR Assembler Code--------- ; ; R17:R16=SQRT(R23:R22:R21:R20) rounded to the nearest integer (0.5 rounds up) ; Destroys the argument in R23:R22:R21:R20 and R0, R1 ; ;----------------------------------- Sqrt32: ldi R19,0xc0 clr R18 ; rotation mask in R19:R18:R0 ldi R17,0x40 clr R16 ; developing sqrt in R17:R16:R1 mul R16,R16 ; R0=R1=0, C=0 _sq32_1: brcs _sq32_2 ; C --> Bit is always 1 cp R21,R1 ; Extra instruction cpc R22,R16 cpc R23,R17 ; Does test value fit? brcs _sq32_3 ; C --> nope, bit is 0 _sq32_2: sub R21,R1 ; Extra instruction sbc R22,R16 sbc R23,R17 ; Adjust argument for next bit or R1,R0 ; Extra instruction or R16,R18 or R17,R19 ; Set bit to 1 _sq32_3: lsr R19 ror R18 ; Shift right mask ror R0 ; Extra instruction eor R1,R0 ; Extra instruction eor R17,R19 eor R16,R18 ; Shift right only test bit in result lsl R20 rol R21 rol R22 rol R23 ; Shift left remaining argument (C used at _sq32_1) sbrs R0,5 ; Skip if 17 bits developed rjmp _sq32_1 ; Develop 17 bits of the sqrt lsl R1 ; C if round up adc R16,R19 adc R17,R19 ; Round up if C (R19=0) ret ################ ab hier das Beispielprogramm ######## ' 32B_SQRT.BAS vom Mo. 15.12.2014 Josef Fenk; ' leider fehlt mir das erforderliche Assemblerwissen, um die Quadratwurzelaufgabe ' loesen zu koennen ' subtraktion und addition in assembler s.u.im Programm von D. Harlos, habe ich mittlerweile verstanden ' ' der sqrt Ansatz ist angelehnt an eine Loesung im AVR microcontroller Forum ' Quadratwurzel von 32Bit Wert; ' Berechnungen von 32BIT Arithmetik ' Umfang: 1224 Basic Bytes; 0 Sys-Bytes; 24 RAM-Bytes=0: ' Zahlenwertebereich der 32 bit Arithmetik ' Dezimal 127 255 255 255 ' 32-Bit-Zahl $007f 00ff 00ff 00ff dezimal ausgeben: 2147483647 ' Dezimal 128 255 255 255 ' 32-Bit-Zahl $0080 00ff 00ff 00ff dezimal ausgeben: -2130706433 ' --------------------------------------------------------------------------- ' habe versucht das ins Programm von Dietmar Harlos einzubinden ' Vorzeichenbehaftete 32-Bit-Arithmetik auf der Open-Micro, Mini und Midi ' von Dietmar Harlos am 29. Juni 2006 ' --------------------------------------------------------------------------- ' --- Betriebssystem konfigurieren ------------------------------------------ INCLUDE "OMAC.DEF" 'Include-Datei mit Definitionen vom April 2010 'INCLUDE "om.def" 'Definitionen fuer die Open-Micro & Open-Mini 'INCLUDE "omid.def" 'Definitionen fuer die Open-Midi ' --------------------------------------------------------------------------- ' --- Definitionen Variable fuer das Hauptprogramm ' ----Def. LONGD Variable umfasst 4 Bytes fuer 32 Bit----------------------- DEFINE Ar_a AS LONG 'Erster 32-Bit-Akkumulator (1. Operand & Rechenergebnis) DEFINE Ar_b AS LONG 'Zweiter 32-Bit-Akkumulator (2. Operand) DEFINE Ar_c AS LONG 'Dritter 32-Bit-Akkumulator (temp. fuer DIV und PRINT32) DEFINE tem AS LONG 'temp. zwischenspeicher DEFINE temp AS LONG 'temp zsichenspeicher DEFINE t_st AS LONG 'Standort Zwischenspeicher temporaer DEFINE Ar_a1 AS BYTE[1] OF Ar_a 'LSB in INLASM == Ar_a+3 DEFINE Ar_a2 AS BYTE[2] OF Ar_a ' in INLASM == Ar_a+2 DEFINE Ar_a3 AS BYTE[3] OF Ar_a ' in INLASM == AR_a+1 DEFINE Ar_a4 AS BYTE[4] OF Ar_a 'MSB in INLASM == Ar_a DEFINE Ar_b1 AS BYTE[1] OF Ar_b 'fuer den Zugriff in BASIC DEFINE Ar_b2 AS BYTE[2] OF Ar_b ' siehe oben zuordnung in INLASM DEFINE Ar_b3 AS BYTE[3] OF Ar_b DEFINE Ar_b4 AS BYTE[4] OF Ar_b DEFINE Ar_c1 AS BYTE[1] OF Ar_c ' fuer den Zugriff in INLASM u. BASIC DEFINE Ar_c2 AS BYTE[2] OF Ar_c ' s.o. zuordnung in INLASM DEFINE Ar_c3 AS BYTE[3] OF Ar_c DEFINE Ar_c4 AS BYTE[4] OF Ar_c DEFINE tem1 AS BYTE[1] OF tem DEFINE tem2 AS BYTE[2] OF tem DEFINE tem3 AS BYTE[3] OF tem DEFINE tem4 AS BYTE[4] OF tem DEFINE temp1 AS BYTE[1] OF temp DEFINE temp2 AS BYTE[2] OF temp DEFINE temp3 AS BYTE[3] OF temp DEFINE temp4 AS BYTE[4] OF temp ' Hauptprogramm----------------------------------------------- ' --------------------------------------------------------------------------- ' Beispiel Zahlenbereich ermitteln 'a3=255:a2=255:a1=255 'FOR a4 = 0 TO 255 ' PRINT "Dezimal ";a4,a3,a2,a1 ' PrintHex=ON ' PRINT "32-Bit-Zahl $";a4,a3,a2,a1;" dezimal ausgeben: "; ' print32 ' PRINTHEX=OFF ' PAUSE 50 'NEXT a4 'Pause 255 'GOTO Multi ' --- Beispiel: Quadrat Wurzel Ar_a4=&h00 Ar_a3=&h00 Ar_a2=&h00 Ar_a1=&h00 Ar_b4=&h00 ' 1 000 000 in Hex = 0F 42 40 Ar_b3=&h0F Ar_b2=&h42 Ar_b1=&h40 PRINT "SQRT_Ber" anzeigen PRINT "SQRT_Erg" sqrt_32 anzeigen GOTO Ende ' --- Beispiel: Addieren --- Ar_a4=&h00 Ar_a3=&h00 Ar_a2=&h10 Ar_a1=&h00 Ar_b4=&h00 Ar_b3=&h00 Ar_b2=&hf0 Ar_b1=&h11 anzeigen PRINT "Additions_Erg" addieren anzeigen ' --- Beispiel: Subtrahieren --- Ar_a4=&h00 Ar_a3=&h00 Ar_a2=&h10 Ar_a1=&h00 Ar_b4=&h00 Ar_b3=&h00 Ar_b2=&hf0 Ar_b1=&h11 PRINT "SUBTRAKTION" anzeigen subtrahieren anzeigen ' --- Beispiel: Multiplizieren --- #Multi Ar_a4=&h00 Ar_a3=&h00 Ar_a2=&h00 Ar_a1=&h12 Ar_b4=&h00 Ar_b3=&h00 Ar_b2=&h27 Ar_b1=&h10 PRINT "MULTIPLIKATION" anzeigen multiplizieren anzeigen ' --- Beispiel: Dividieren --- Ar_a4=&h00 Ar_a3=&h02 Ar_a2=&hbf Ar_a1=&h20 Ar_b4=&h00 Ar_b3=&h00 Ar_b2=&h00 Ar_b1=&h3c PRINT "DIVISION" anzeigen dividieren anzeigen ' --- Beispiel: Rest der Division --- Ar_a4=&h00 Ar_a3=&h00 Ar_a2=&h00 Ar_a1=&h07 Ar_b4=&h00 Ar_b3=&h00 Ar_b2=&h00 Ar_b1=&h05 PRINT "REST DIVISION" anzeigen modulo anzeigen ' --- Beispiel: Ausgabe von 32-Bit-Zahlen --- Ar_a4=&h7f '7f werte im original Ar_a3=&hff 'ff Ar_a2=&hff 'ff Ar_a1=&hff 'ff PRINT "Dezimal ";Ar_a4,Ar_a3,Ar_a2,Ar_a1 PrintHex=ON PRINT "32-Bit-Zahl $";Ar_a4,Ar_a3,Ar_a2,Ar_a1;" dezimal ausgeben: "; print32 PRINTHEX=OFF Ar_a4=&h80 Ar_a3=&h00 Ar_a2=&h00 Ar_a1=&h00 PRINT "Dezimal ";Ar_a4,Ar_a3,Ar_a2,Ar_a1 PrintHex=ON PRINT "32-Bit-Zahl $";Ar_a4,Ar_a3,Ar_a2,Ar_a1;" dezimal ausgeben: "; print32 PRINTHEX=OFF End2Host=ON #Ende END ' ****** Subroutinen ' --------------------------------------------------------------------------- ' Akkumulatoren ausgeben PROC anzeigen PrintHex=ON ' PRINT "Akku1: $";Ar_a4;Ar_a3;Ar_a2;Ar_a1 PRINT "Akku1: $";Ar_a4;Ar_a3;Ar_a2;Ar_a1;" dezimal ausgeben: "; print32 ' PRINT "Akku2: $";Ar_b4;Ar_b3;Ar_b2;Ar_b1 ' tem4=Ar_a4:tem3=Ar_a3:tem2=Ar_a2:tem1=Ar_a1 ' eingefuegt um richtige Ausgabe b zu erhalten Ar_a4=Ar_b4:Ar_a3=Ar_b3:Ar_a2=Ar_b2:Ar_a1=Ar_b1 PRINT "Akku2: $";Ar_b4;Ar_b3;Ar_b2;Ar_b1;" dezimal ausgeben: "; print32 ' Ar_a4=tem4:Ar_a3=tem3:Ar_a2=tem2:Ar_a1=tem1 PrintHex=OFF RETURN ' --------------------------------------------------------------------------- ' Subroutine//Procedure fuer Wurzel//Square root aus 32-Bit Zahl PROC sqrt_32 INLASM '----Mo. 15.12.2014: Versuch umsetzung von AVR Assembler auf OMACRO INLASM --------------- ' R17:R16=SQRT(R23:R22:R21:R20) rounded to the nearest integer (0.5 rounds up) ' Destroys the argument in R23:R22:R21:R20 and R0, R1 ' statt R19, R18, R17, R16 hier Ar_a4, Ar_a3, Ar_a2, Ar_a1 ' statt R23, R22, R21, R20 hier Ar_b4, Ar_b3, Ar_b2, Ar_b1 ' Eingabewert in Ar_b ' Ausgabewert in Ar_a2=High byte:Ar_a1=Low Byte ' bei mul statt R0 product low byte hier accumulator low byte ' bei mul statt R1 product high byte hier high byte in index register low byte ' bei AVR: mul R16,R16;unsigned 16 bit Ergebnis ist in ' High byte in R1 u. Low byte in R0; R0=R1=0, C=0 ' bei OMACRO-uC: Variable Ar_a1 muss erst in index register low byte und ' im accumulator abgespeichert werden ' Ergebnis high byte in x-register u. lower byte in accu ' Ergebnisse in x-register und accu deshalb abspeichern in ' Ar_c2 = high byte und Ar_c1 = low byte '------------------------------------------------------------------- '#Sqrt32 ! ldx #Ar_a Ar_a4=&hc0 ' statt ldi R19,0xc0 ! clr Ar_a+1 ' statt clr R18; rotation mask in R19:R18:R0 Ar_a2=&h40 ' statt ldi R17,0x40 ! clr Ar_a+3 ' statt clr R16; developing sqrt in R17:R16:R1 ' bei AVR: mul R16,R16;unsigned 16 bit Ergebnis ist in ' High byte in R1 u. Low byte in Ro; R0=R1=0, C=0 ! lda Ar_a+3 'bei OMACRO-uC: Ar_a1 muss erst in index register low byte und ! ldx Ar_a+3 'im accumulator abgespeichert werden ! mul ' Ergebnis high byte in x-register u. lower byte in accu ! sta Ar_c+3 ' low byte von accu in Ar_c1 zwischengespeichert==AVR R0 ! stx Ar_c+2 ' high byte von index register in Ar_c2 zwischengespeichert==AVR R0 #sq32_1 ! bcs sq32_2 ' statt branch if carry bit set: brcs _sq32_2 ' C --> Bit is always 1 ! lda Ar_b+2 ' statt cp R21,R1 ' Extra instruction ! cmp Ar_c2 ! sta Ar_b+2 '! ???cpc ' compare with carry cpc R22,R16 ! lda Ar_b+3 ! cmp Ar_a+3 ! sta Ar_b+3 '! ???cpc ' cpc R23,R17 ' Does test value fit? ! lda Ar_b ! cmp Ar_a+2 ! sta Ar_b ! bcs sq32_3 ' statt brcs _sq32_3 ' C --> nope, bit is 0 #sq32_2 ! lda Ar_b+2 ' statt sub R21,R1 ' Extra instruction ! sub Ar_c+2 ! sta Ar_b+2 ! lda Ar_b+1 ' statt sbc R22,R16 ! sbc Ar_a+3 ! sta Ar_b+1 ! lda Ar_b ' statt sbc R23,R17 ' Adjust argument for next bit ! sbc Ar_a+2 ! sta Ar_b '??? ' statt or R1,R0 ' Extra instruction ! lda Ar_c+2 ! ora Ar_c+3 ! sta Ar_c+2 ' ob das stimmt??? ! lda Ar_a+3 ' statt or R16,R18 ! ora Ar_a+1 ! sta Ar_a+3 ! lda Ar_a+2 ' statt or R17,R19 ' Set bit to 1 ! ora Ar_a ! sta Ar_a+2 #sq32_3 ! lsr Ar_a ' statt lsr R19 ! ror Ar_a+1 ' statt ror R18 ' Shift right mask ' statt ror R0 ' Extra instruction ! ror Ar_c+3 ' wert von Ar_c1 rotate right throuhg carry ' statt eor R1,R0 ' Extra instruction ! lda Ar_c+2 ' wert von Ar_c2 == AVR R1 in Akku ! eor Ar_c+3 ' dann exclusive OR vergleich mit Wert Ar_c1 ! sta Ar_c+2 ' wert von akku zurueck in Ar_c3 ! lda Ar_a+2 ' statt eor R17,R19 ! eor Ar_a ! sta Ar_a+2 ! lda Ar_a+3 ' statt R16,R18 ' Shift right only test bit in result ! eor Ar_a+1 ! sta Ar_a+3 ! lsl Ar_b+3 ' statt lsl R20 ! rol Ar_b+2 ' statt rol R21 ! rol Ar_b+1 ' statt rol R22 ! rol Ar_b ' statt rol R23; Shift left remaining argument (C used at _sq32_1) '! ??sbrs R0,5 'skip if bit 5 in register R0 is set: sbrs R0,5 ' Skip if 17 bits developed ! brset 5,Ar_c+4,We ' vielleicht funktioniert das ! jsr sq32_1 ' statt rjmp _sq32_1; relative jump: Develop 17 bits of the sqrt #We ' ueberspringt jsr ! lsl Ar_c+2 ' statt lsl R1 ; ' C if round up ! lda Ar_a+3 ' statt adc R16,R19 ! adc Ar_a ! sta Ar_a+3 ! lda Ar_a+2 ' statt adc R17,R19 ' Round up if C (R19=0) ! adc Ar_a ! sta Ar_a+2 ! rts END PROC ' Subroutine zur 32-Bit-Addition PROC addieren INLASM ! lda Ar_a+3 ' dies entspricht Ar_a1 ! add Ar_b+3 ! sta Ar_a+3 ! lda Ar_a+2 ! adc Ar_b+2 ! sta Ar_a+2 ! lda Ar_a+1 ! adc Ar_b+1 ! sta Ar_a+1 ! lda Ar_a ' dies ist gleich Ar_a4 ! adc Ar_b ! sta Ar_a ! rts END PROC ' Subroutine zur 32-Bit-Subtraktion PROC subtrahieren INLASM ! lda Ar_a+3 ' entspricht Ar_a1 vermutlich ! sub Ar_b+3 ! sta Ar_a+3 ! lda Ar_a+2 ! sbc Ar_b+2 ! sta Ar_a+2 ! lda Ar_a+1 ! sbc Ar_b+1 ! sta Ar_a+1 ! lda Ar_a ! sbc Ar_b ! sta Ar_a ! rts END PROC ' Schnelle 32-Bit-Multiplikation mit 32-Bit-Ergebnis ' von Dietmar Harlos ADPC am 7. Juni 2006 ' recht schnell und recht kurz - laesst sich aber noch optimieren PROC multiplizieren INLASM ! ldx #Ar_a #mul_8 ! lda ,x ! pusha ! clr ,x ! incx ! cmpx #Ar_a+#4 ! bne mul_8 ! ldx #4 #mul_1 ! popa ! pushx ! stx ostemp ! bsr mul_2 ! popx ! dbnzx mul_1 ! rts #mul_2 ! ldx Ar_b+3 ! bsr mul_3 ! ldx Ar_b+2 ! bsr mul_3 ! ldx Ar_b+1 ! bsr mul_3 ! ldx Ar_b ! bsr mul_3 #mul_3 ! pusha ! mul ! bsr mul_4 ! dbnz ostemp,mul_5 ! ais #3 ! rts 'Ruecksprung hinter das BSR mul_2 #mul_4 ! pushx #mul_5 ! ldx ostemp ! clc #mul_6 ! adc Ar_a-1,x ! sta Ar_a-1,x ! bcc mul_7 ! clra ! dbnzx mul_6 #mul_7 ! popa ! rts END PROC ' Subroutine zur vorzeichenbehafteten 32-Bit-Division PROC dividieren INLASM ! bsr makepositive ! pusha ! bsr udiv32 #dividieren_from_mod ! popa ! tsta ! bpl negate_a_1 #negate_a ! com Ar_a ! com Ar_a+1 ! com Ar_a+2 ! neg Ar_a+3 ! blo negate_a_1 ! inc Ar_a+2 ! bne negate_a_1 ! inc Ar_a+1 ! bne negate_a_1 ! inc Ar_a #negate_a_1 ! rts #makepositive ! lda Ar_a ! xor Ar_b ! brclr #7,Ar_a,makepositive_1 ! bsr negate_a #makepositive_1 ! brclr #7,Ar_b,negate_b_1 #negate_b ! com Ar_b ! com Ar_b+1 ! com Ar_b+2 ! neg Ar_b+3 ! blo negate_b_1 ! inc Ar_b+2 ! bne negate_b_1 ! inc Ar_b+1 ! bne negate_b_1 ! inc Ar_b #negate_b_1 ! rts END PROC ' Subroutine fuer vorzeichenbehaftetes 32-Bit-Modulo PROC modulo INLASM ! bsr makepositive ! pusha ! bsr udiv32 ! mov Ar_c+3,Ar_a+3 ! mov Ar_c+2,Ar_a+2 ! mov Ar_c+1,Ar_a+1 ! mov Ar_c ,Ar_a ! bra dividieren_from_mod END PROC ' 32-Bit-Division mit 32-Bit Ergebnis ' von Dietmar Harlos ADPC am 29. Juni 2006 ' geschwindigkeitsmaessig gaebe es einiges zu verbessern PROC udiv32 INLASM ! clr Ar_c 'Akkumulator (und Rest) c loeschen ! clr Ar_c+1 ! clr Ar_c+2 ! clr Ar_c+3 ! mov #32,OSTEMP #udiv32_1 ! lsl Ar_a+3 'Divident (und Quotient, Ergebnis) a nach links ... ! rol Ar_a+2 ! rol Ar_a+1 ! rol Ar_a ! rol Ar_c+3 ' in den Akkumulator c schieben ! rol Ar_c+2 ! rol Ar_c+1 ! rol Ar_c ! lda Ar_c+3 'Akkumulator c minus Divisor b ! sub Ar_b+3 ! lda Ar_c+2 ! sbc Ar_b+2 'Zwischenspeichern der ersten Ergebnisse per PUSHA ! lda Ar_c+1 ' macht keinen Sinn, da der Akku in den meisten ! sbc Ar_b+1 ' Faellen nicht aktualisiert werden muss. ! tax ! lda Ar_c ! sbc Ar_b ! bcs udiv16_2 'C ist gesetzt, wenn Akkumulator kleiner als Divisor ! sta Ar_c ! stx Ar_c+1 'wenn nicht zu klein, dann Akkumulator aktualisieren ! lda Ar_c+3 ! sub Ar_b+3 ! sta Ar_c+3 ! lda Ar_c+2 ! sbc Ar_b+2 ! sta Ar_c+2 ! inc Ar_a+3 ' und LSB vom Quotienten setzen #udiv16_2 ! dbnz OSTEMP,udiv32_1 ! rts END PROC ' Subroutine zur dezimalen Ausgabe von vorzeichenbehafteten 32-Bit-Zahlen ' von Dietmar Harlos ADPC am 29. Juni 2006 ' benoetigt bei aktiviertem Interruptsystem 21 Byte Hardwarestack PROC print32 INLASM ! mov Ar_a+3,Ar_c+3 'Akkumulator a nicht veraendern ! mov Ar_a+2,Ar_c+2 ! mov Ar_a+1,Ar_c+1 ! mov Ar_a ,Ar_c ! brclr #7,Ar_c,print32_1 ! lda #"-" ! jsr FwPutSci ! com Ar_c 'Zahl negieren, falls negativ ! com Ar_c+1 ! com Ar_c+2 ! neg Ar_c+3 ! blo print32_1 ! inc Ar_c+2 ! bne print32_1 ! inc Ar_c+1 ! bne print32_1 ! inc Ar_c #print32_1 ! ldx #10 ! clr OSTEMP #print32_2 ! inc OSTEMP ! clrh ! lda Ar_c ! div 'Division 32-Bit durch 8-Bit ! sta Ar_c ! lda Ar_c+1 ! div ! sta Ar_c+1 ! lda Ar_c+2 ! div ! sta Ar_c+2 ! lda Ar_c+3 ! div ! sta Ar_c+3 ! pushh ! ora Ar_c+2 ! ora Ar_c+1 ! ora Ar_c ! bne print32_2 #print32_3 ! popa 'Ziffern ausgeben ! add #"0" ! jsr FwPutSci ! cli ! dbnz OSTEMP,print32_3 ! rts END PROC ' --------------------------------------------------------------------------- INCLUDE "OM_FW.PRO" |
| Antwort schreiben |
Re: Quadratwurzel von 32 Bit Zahl (von Dietmar - 16.12.2014 20:23)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 18.12.2014 18:25)Re: Quadratwurzel von 32 Bit Zahl (von Dietmar - 18.12.2014 20:20)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 19.12.2014 10:57)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 19.12.2014 15:57)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 19.12.2014 16:12)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 20.12.2014 0:32)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 20.12.2014 20:59)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 20.12.2014 22:43)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 23.12.2014 20:10)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 28.12.2014 14:48)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 30.12.2014 19:47)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 31.12.2014 17:46)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 7.01.2015 15:15)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 9.01.2015 9:53)Re: Quadratwurzel von 32 Bit Zahl (von GeKue - 29.01.2015 12:39)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 31.01.2015 15:35)Re: Quadratwurzel von 32 Bit Zahl (von Joe - 2.04.2015 16:35)