Kod: Markera allt
From binary to BCD
; Bin2ToBcd5
; ==========
; converts a 16-bit-binary to a 5-digit-BCD
; In: 16-bit-binary in rBin1H:L, Z points to first digit
; where the result goes to
; Out: 5-digit-BCD, Z points to first BCD-digit
; Used registers: rBin1H:L (unchanged), rBin2H:L (changed),
; rmp
; Called subroutines: Bin2ToDigit
;
Bin2ToBcd5:
push rBin1H ; Save number
push rBin1L
ldi rmp,HIGH(10000) ; Start with tenthousands
mov rBin2H,rmp
ldi rmp,LOW(10000)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
ldi rmp,HIGH(1000) ; Next with thousands
mov rBin2H,rmp
ldi rmp,LOW(1000)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
ldi rmp,HIGH(100) ; Next with hundreds
mov rBin2H,rmp
ldi rmp,LOW(100)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
ldi rmp,HIGH(10) ; Next with tens
mov rBin2H,rmp
ldi rmp,LOW(10)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
st z,rBin1L ; Remainder are ones
sbiw ZL,4 ; Put pointer to first BCD
pop rBin1L ; Restore original binary
pop rBin1H
ret ; and return
;
; Bin2ToDigit
; ===========
; converts one decimal digit by continued subraction of a
; binary coded decimal
; Used by: Bin2ToBcd5, Bin2ToAsc5, Bin2ToAsc
; In: 16-bit-binary in rBin1H:L, binary coded decimal in
; rBin2H:L, Z points to current BCD digit
; Out: Result in Z, Z incremented
; Used registers: rBin1H:L (holds remainder of the binary),
; rBin2H:L (unchanged), rmp
; Called subroutines: -
;
Bin2ToDigit:
clr rmp ; digit count is zero
Bin2ToDigita:
cp rBin1H,rBin2H ; Number bigger than decimal?
brcs Bin2ToDigitc ; MSB smaller than decimal
brne Bin2ToDigitb ; MSB bigger than decimal
cp rBin1L,rBin2L ; LSB bigger or equal decimal
brcs Bin2ToDigitc ; LSB smaller than decimal
Bin2ToDigitb:
sub rBin1L,rBin2L ; Subtract LSB decimal
sbc rBin1H,rBin2H ; Subtract MSB decimal
inc rmp ; Increment digit count
rjmp Bin2ToDigita ; Next loop
Bin2ToDigitc:
st z+,rmp ; Save digit and increment
ret ; doneKod: Markera allt
.
****** CONVERT BINARY TO BCD
*
* IN: A=BINARY NUMBER
* OUT: BCDACC=PACKED BCD PLUS 100:TH DIGIT IN BCDACC.100
*
* ORIGINAL CODE BY SCOTT DATTELO
* CONVERTED AND RECOMMENTED BY MARTA
*
BINBCD LOD BCDACC,A USE AS SCRATCH
STZ BCDACC.100 CLEAR 100:TH
SWN A=BCDACC THIS GIVES 1 FOR 16, 2 FOR 32..
* ..4 FOR 64 AND 8 FOR 128
ADD A,BCDACC ADD IN 0 TO 9 OF THE BINARY NUMBER..
* ..1 FOR 16 IS GARBAGE, COMPENSATED LATER ON
AND A,#b0000_1111 MASK OUT LOW NIBBLE, CARRY PRESERVED IN HC
SFC HC WAS THERE A HALF CARRY
ADD A,#$16 YES- ADD IN AS BCD
SFC HC DID LOW DIGIT OVERFLOW?
ADD A,#$06 YES-ADD IN BCD ADJUSTMENT
* BCD ADJUSTMENT TO ASSURE NO OVERFLOW NEXT
ADD A,#$06 TRY ADD IN BCD ADJUSTMENT
SFS HC BCD WRAP OVER?
ADD A,#-$06 NO-UNADJUST
SBR BCDACC,4 IS THERE A 16 BIT?
ADD A,#$16-1+$6 YES-ADD IN MINUS GARBAGE 1 FROM ABOVE..
* ..ALSO TRY BCDADJ (THE $6 TERM)
SFS HC BCD WRAP OVER?
ADD A,#-$06 NO-UNADJUST
* THESE ONLY ON HIGH NIBBLE, BCD ADJ NEVER NEEDED
SBR BCDACC,5 ADD IN 10:TH OF 32
ADD A,#$30
SBR BCDACC,6 ADD IN 10:TH OF 64
ADD A,#$60
* DO 128 BIT
SBR BCDACC,7 IS THERE A 128 BIT?
ADD A,#$20 ADD IN 10:TH OF 128
ADD A,#$60 TRY BCD ADJUST HIGH NIBBLE
ROL BCDACC.100 ROTATE IN EVENTUAL CARRY AS 100:TH
SBS BCDACC.100,0 WAS THERE A BCD OVERFLOW?
ADD A,#-$60 NO-UNADJUST
SBR BCDACC,7 ADD IN 100:TH OF 128..
INC BCDACC.100 ..BY INCREMENTING 100:TH DIGIT
LOD BCDACC,A SAVE TWO LOWEST BCD DIGITS
RTS DONE
Blandade nog ihop rubrikerna på trådarna för jag var övertygad om att han hade en ATmega8.
Kod: Markera allt
A är 16 bitars tal - det tal som ska visas
B är 16 bitars tal
C är adresspekare till plats i ram-minne (eller pekare i Array)
siffra är ett 8-bitars tal. (BCD)
efter avslutad omvandling innehåller
(C) 5 st BCD-siffror t.ex. 00123
sätt C till adress
Läs in talet i A
sätt B till 10000
beräkna siffra ; (subrutin)
spara siffra i (C)
inc C
sätt B till 1000
beräkna siffra ; (subrutin)
spara siffra i (C)
inc C
sätt B till 100
beräkna siffra ; (subrutin)
spara siffra i (C)
inc C
sätt B till 10
beräkna siffra ; (subrutin)
spara siffra i (C)
inc C
spara låga byte av A i (C) ; sista siffran
; subrutin
beräkna_siffra:
sätt siffra till 0
loop:
är A<B ? { exit loop }
A=A-B
inc siffra
end loopsprintf() är förstås bekvämast men då blir man av med löjligt mycket programminne också, och cykelantalen blir femsiffriga...bearing skrev:Måste ju vara både enklare och snabbare att göra som i bos exempel.
