Umwandlung 16Bit Hex-Wert in BCD mit 8Bit µC Infineon SAB80C515

[Hubert W. (hubert83)]

Hallo.

Darf mit kurz mal vorstellen. Bin angehender Elektrotechniker und 
betreibe die Mikrocontrollerprogrammierung hobbymässig. Habe das Forum 
des öfteren aufgesucht und immer eine Antwort auf meine Frage gefunden. 
Jetzt habe ich aber eine Sache, die ich auch mit der Suchfunktion nicht 
lösen konnte.
Es geht um folgendes.
Verwende folgenden Mikrocontroller: Infineon SAB80C515
Mit diesem Mikrocontroller habe ich folgendes vor bzw. geplant. Wie mit 
dem Timer 0 die Impulslänge eines externen Impulses im bereich von 0µs 
bit 65535µs messen und diesen Wert als BCD ausgeben. Mein Problem liegt 
nun daran, dass diese Controller nur 8Bit Zahlen verarbeiten kann. Wie 
zerlege ich nun die zwei 8Bit Zahlen so, dass auch der richtige Wert des 
Impulses an der Anzeige auftaucht. Bei Zahlen bis 255 habe ich es 
folgendesmassen gemacht:

MOV A,TL0 // Lade Timerwert low von T0 in Akku
MOV B,#0AH // Schiebe 10 in B-Register
DIV AB // Teile Akku durch B Register
MOV _1er,B // Schiebe Divisionsrest von B-Register in 1er Speicher
MOV B,#0AH // Schiebe 10 in B-Register
DIV AB // Teile Akku durch B Register
MOV _10er,B // Schiebe Divisionsrest von B-Register in 10er Speicher
MOV _100er,A // Schiebe Quotient von Akku in 100er Speicher

Leider funktioniert das bei Zahlen größer 255 nicht mehr, da der µC 
keine 16Bit Zahlen dividieren kann. Habe es schon mit der Subdraktione 
der beiden 8Bit hälfen in 10000er, 1000er, 100er, 10er und 1er versucht, 
aber irgendwie funktioniert das auch nicht. Ich hoffe es hat jemand von 
euch eine guten Ansatz wie ich das Problem am einfachsten lösen kann. PS 
ich schreibe die Programm in Assembler. Bin für jede Hilfestellung 
dankbar.

Gruß

Hubert83

[PillePalle (Gast)]

Moin

leider nur für Atmel ,aber das Prinzip dürfte dadurch ja klar werden :-)

“bin2BCD16” implements the following algorithm:
1. Load Loop counter with 16.
2. Clear all three bytes of result.
3. Shift left input value Low byte.
4. Shift left carry into input value High byte.
5. Shift left carry into result byte 0 (two least significant digits).
6. Shift left carry into result byte 1.
7. Shift left carry into result byte 2 (most significant digit).
8. Decrement Loop counter
9. If Loop counter is zero, return from subroutine.
10. Add $03 to result byte 2.
11. If bit 3 is zero after addition, restore old value of byte 2.
12. Add $30 to result byte 2.
13. If bit 7 is zero after addition, restore old value of byte 2.
14. Add $03 to result byte 1.
15. If bit 3 is zero after addition, restore old value of byte 1.
16. Add $30 to result byte 1.
17. If bit 7 is zero after addition, restore old value of byte 1.
18. Add $03 to result byte 0.
19. If bit 3 is zero after addition, restore old value of byte 0.
20. Add $30 to result byte 0.
21. If bit 7 is zero after addition, restore old value of byte 0.
22. Goto Step 3.
In the implementation. Steps 10 - 21 are carried out inside a loop, 
where the Z-pointer is
used for successive access of all three bytes of the result. This is 
shown in the flow chart
shown in Figure 1.

weiter gehts bei www.atmel.com
http://www.atmel.com/dyn/products/app_notes.asp?family_id=607
dort dann die Applikation Nr. AVR204 ( BCD Arithmetics )

[Peter D. (peda)]

Es gibt 2 übliche Methoden:

1. Digit = Anzahl der Subtraktion von Zehnerpotenzen

        mov     r6, #low(60900)
        mov     r7, #high(60900)
        call    bcd
        mov     r6, #low(09090)
        mov     r7, #high(09090)
        call    bcd
        mov     r6, #low(12345)
        mov     r7, #high(12345)
        call    bcd
        jmp     $

;input: R7, R6 = 16 bit value 0 ... 65535
;output: R7, R6, R5, R4, R3 = digits (ASCII)
;cycle: 37 .. 220
;bytes: 44
;
bcd:    mov     a, r7
        mov     r3, a
        mov     a, r6
        mov     r7, #-1 + '0'
?bcd1:  inc     r7
        add     a, #low(-10000)
        xch     a, r3
        addc    a, #high(-10000)
        xch     a, r3
        jc      ?bcd1
        mov     r6, #10 + '0'
?bcd2:  dec     r6
        add     a, #low(1000)
        xch     a, r3
        addc    a, #high(1000)
        xch     a, r3
        jnc     ?bcd2
        mov     r5, #-1 + '0'
        inc     r3
?bcd3:  inc     r5
        add     a, #low(-100)
        jc      ?bcd3
        djnz    r3, ?bcd3
        mov     r4, #10 + '0'
?bcd4:  dec     r4
        add     a, #10
        jnc     ?bcd4
        add     a, #'0'
        mov     r3, a
        ret

end

2. Digit = Rest aus Division / 10

        mov     r6, #low(12345)
        mov     r7, #high(12345)
        call    bcd
        jmp     $

;input: R7, R6 = value
;output: R7, R6, R5, R4, R3 = digits
;cycle: 292
;bytes: 40
;
        using   0
bcd:
        mov     a, r6
        mov     r2, a
        mov     r1, #ar3        ;point to r3
?bcd1:  mov     r0, #ar7        ;point to msb
        setb    f0
        clr     a
?bcd2:  xch     a, @r0
        xchd    a, @r0
        swap    a
        mov     b, #10
        div     ab              ;high nibble / 10
        swap    a
        xch     a, @r0
        swap    a
        add     a, b
        swap    a
        mov     b, #10
        div     ab              ;low nibble / 10
        xchd    a, @r0
        mov     a, b
        mov     r0, #ar2        ;point to lsb
        jbc     f0, ?bcd2
        mov     @r1, a
        inc     r1
        cjne    r1, #ar7+1, ?bcd1
        ret

end

Peter