Este blog lo voy a dedicar a subir algunos códigos básicos de programación en distintos lenguajes. Creo que a veces es bueno tener una idea de como iniciar algo, a mi me sucedía, y me hubiera gustado encontrar algún código que me ayudara a ordenar mis ideas... Yo buscaba mucho algunos códigos y no los encontraba, casos como verilog, vhdl y codigos en ensamblador para micros de freescale en especifico los de la familia flexis. Así que aquí voy a ir dejando algunos codigos, espero ayudar a alguien a entender estos codigos. (Dejé de adentrarme en la programación de los microcontroladores, pero eso no implica que me hayan dejado de gustar. Voy a tratar de dejar entradas del avance que van teniendo y con ellos los gadgets que podremos ver.)

lunes, 20 de febrero de 2012

Codigo ensamblador para convertir de binario a bcd

/**** Aquí dejo esta parte de código, espero poder subir todo lo que haga  de ensamblador de freescale, me parecen buenas aportaciones porque no he encontrado mucho de 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     //declaramos la subrutina bintobcd
   
     BRA       _main  
   
   
BinToBCD:                   //creamos la etiqueta BinToBcd
     move.l    #0,d0    //limpiamos el registro d0
     move.b    d0,dm        //movemos lo que hay en d0 a las demas variables para limpiarlas
     move.b    d0,m
     move.b    d0,c
     move.b    d0,d
     move.b    d0,u
   
     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, si no, va a la siguiente linea
     subi.l    #10000,d0    // si no es menor le restamos 10000 a d0 es decir 65535-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 lleguemos hasta aqui.
   
Millar:    //creamos la etiqueta Millar
     move.b    d1,dm        // movemos lo que quedo en d1 a dm que eria en este caso 6
     move.b    m,d1    // ahora movemos lo que hay en m a d1 que es un 0 para limpiar
MilLoop:                    // Creamos la etiqueta MilLoop
     cmpi.l    #1000,d0     // Comparamos 1000 con lo que quedo en d0
     blo       Centena      // brincamos a Centena si d0 es menor que 1000
     subi.l    #1000,d0     // le restamos 1000 a d0 es decir 5535-1000
     addi.l    #1,d1        // aumentamos 1 a d1
     bra       MilLoop      // regresamos a la etiqueta MilLoop
   
Centena:                    // creamos la etiqueta Centena
     move.b    d1,m         // movemos lo que quedo en d1 a m en este caso es 5
     move.b    c,d1         // movemos el cero de c a d1 para limpiar
CenLoop:                    // creamos la etiqueta CenLoop
     cmpi.l    #100,d0      // comparamos 100 con lo que hay en d0 que es 535
     blo       Decena       // si d0 es menor que 100 brincamos a Decena
     subi.l    #100,d0      // le restamos a d0 100 es decir 535-100
     addi.l    #1,d1        // aumentamos 1 a d1
     bra       CenLoop      // regresamos a la etiqueta CenLoop
   
Decena:                     // Creamos la etiqueta Decena
     move.b    d1,c         // movemos lo que hay en d1 a c que seria en este caso 5
     move.b    d,d1         // movemos el 0 que hay en d a d1 para limpiar
DecLoop:                    // creamos la etiqueta DecLoop
     cmpi.l    #10,d0       // comparamos 10 con lo que hay en d0
     blo       Unidad       // si d0 es menor que 10 brincamos a unidad
     subi.l    #10,d0       // le restamos 10 a d0 es decir 35-10
     addi.l    #1,d1        // agregamos 1 a d1
     bra       DecLoop      // regresamos a la etiqueta DecLoop
   
Unidad:                     // Creamos la etiqueta Unidad
     move.b    d1,d         // movemos lo que hay en d1 a d que en este caso es 3
     move.b    d0,u         // finalmente lo que quedo en d0 que es un 5 se mueve a u
     RTS                    // retornamos a la subrutina
Publicado por en

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)