Codigo ensamblador para convertir de binario a bcd

/**** Aqu dejo esta parte de cdigo, espero poder subir todo lo que haga de ensambla
dor de freescale, me parecen buenas aportaciones porque no he encontrado mucho d
e esta arquitectura, espero les sirva******/
/*****************************************************************************/
.extern ___SP_INIT
.global _main
.global _asm_startup
.include "derivative.inc"
/*****************************************************************************/
/* Declaracion de variables */
/*****************************************************************************/
.bss
Dato: .space 2
dm: .space 1
m: .space 1
c: .space 1
d: .space 1
u: .space 1
/*****************************************************************************/
/* Declaracion de constantes */
/*****************************************************************************/
.text
.align 4
/*****************************************************************************/
/*****************************************************************************/
/* Start Up Code */
_asm_startup:
/* disable interrupts */
move.w #$2700,SR
/* setup the stack pointer */
lea
___SP_INIT,A7
/* WDT Disable */
move.b #$23,d1
move.b d1,SOPT1
/*****************************************************************************/
/*****************************************************************************/
/* Main Function */
/*****************************************************************************/
/*****************************************************************************/
_main:
move.l
#65535,d0
// movemos el numero al registro d0
move.w
d0,Dato
//movemos lo que hay en d0 a la variable Dato
BSR

BinToBCD

BRA

_main

BinToBCD:
move.l
move.b
a limpiarlas
move.b
move.b
move.b
move.b

#0,d0
d0,dm
d0,m
d0,c
d0,d
d0,u

//declaramos la subrutina bintobcd

//creamos la etiqueta BinToBcd

//limpiamos el registro d0
//movemos lo que hay en d0 a las demas variables par

move.w
Dato,d0
// movemos lo que hay en Dato a d0 que es el 65535
move.b
dm,d1
//movemos lo que hay en dm a d1 en este caso 0 para
limpiar
DecMilLoop:
//creamos la etiqueta DecMilLoop
cmpi.l
#10000,d0
//comparamos si lo que hay en d0 es menor a 10000
blo
Millar
// brincamos a millar si d0 ya es menor que 10000, s
i no, va a la siguiente linea
subi.l
#10000,d0
// si no es menor le restamos 10000 a d0 es decir 65
535-1000
addi.l
#1,d1
// le sumamos 1 a d1, d1 se va a estar incrementando
como un contador
bra
DecMilLoop //regresamos a la etiqueta DecMilLoop siempre que ll
eguemos hasta aqui.
Millar:
move.b
caso 6
move.b
impiar
MilLoop:
cmpi.l
blo
subi.l
addi.l
bra
Centena:
move.b
move.b
CenLoop:
cmpi.l
blo
subi.l
addi.l
bra
Decena:
move.b
so 5
move.b
DecLoop:
cmpi.l
blo
subi.l
addi.l
bra
Unidad:
move.b
3
move.b
e a u
RTS

//creamos la etiqueta Millar

d1,dm
// movemos lo que quedo en d1 a dm que eria en este
m,d1

// ahora movemos lo que hay en m a d1 que es un 0 para l

//
//
//
//
//
//

Creamos la etiqueta MilLoop

Comparamos 1000 con lo que quedo en d0
brincamos a Centena si d0 es menor que 1000
le restamos 1000 a d0 es decir 5535-1000
aumentamos 1 a d1
regresamos a la etiqueta MilLoop

#100,d0
Decena
#100,d0
#1,d1
CenLoop

//
//
//
//
//
//
//
//
//

creamos la etiqueta Centena

movemos lo que quedo en d1 a m en este caso es 5
movemos el cero de c a d1 para limpiar
creamos la etiqueta CenLoop
comparamos 100 con lo que hay en d0 que es 535
si d0 es menor que 100 brincamos a Decena
le restamos a d0 100 es decir 535-100
aumentamos 1 a d1
regresamos a la etiqueta CenLoop

d1,c

// Creamos la etiqueta Decena

// movemos lo que hay en d1 a c que seria en este ca

#1000,d0
Centena
#1000,d0
#1,d1
MilLoop
d1,m
c,d1

d,d1
#10,d0
Unidad
#10,d0
#1,d1
DecLoop

//
//
//
//
//
//
//

movemos el 0 que hay en d a d1 para limpiar

creamos la etiqueta DecLoop
comparamos 10 con lo que hay en d0
si d0 es menor que 10 brincamos a unidad
le restamos 10 a d0 es decir 35-10
agregamos 1 a d1
regresamos a la etiqueta DecLoop

d1,d

// Creamos la etiqueta Unidad

// movemos lo que hay en d1 a d que en este caso es

d0,u

// finalmente lo que quedo en d0 que es un 5 se muev

// retornamos a la subrutina