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.)

miércoles, 21 de marzo de 2012

Escritura en lcd de 16x2 programa en ensamblador

/* Aquí dejo el código en ensamblador para el micro de freescale de la serie MM 256 **/
/**Prueben con distintos códigos de inicialización para la lcd, yo tuve ese problema, tuve que cambiar mas de tres ocasiones el código de inicializacion porque para cada lcd es diferente. Observen que estoy utilizando muchos registros para los datos, si pueden utilizar menos esta perfecto. Este código lo hice muy rápido y no me senté a optimizarlo, solo espere que prendiera la pantalla y entregue la practica. Observe que utilicé solamente cuatro bits del puerto en el micro para mandar los datos a la lcd, esto es importante por eso prendo y apago mas seguido el enable, si quieren para 8 bits es un poco mas sencillo, después subo el código para 8 bits.

He tardado en subir los códigos porque quiero subir todos los códigos comentados para que sepan a que se refiere cada linea, me parece importante eso para que puedan comprender el código a fondo.
     .extern   ___SP_INIT  
     .global _main
     .global _asm_startup
     .include "derivative.inc"
/*****************************************************************************/
/*  Variables Declaration */
/*****************************************************************************/
     .bss
   
/*****************************************************************************/
/*  Constants declaration */
/*****************************************************************************/
 .text
      config: .byte $36, $36, $36, $06, $06, $01
       msg1: .byte "hola"

     .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.b #%11000000,d0
      move.b d0,PTCDD      //activando como salida pin 6 y 7 para enable y Rs respectivamente del puerto D
      move.b #%11110000,d1
      move.b d1, PTHDD     //activando como salida de los datos los primeros cuatro pines del puerto H
      move.b #0, d4


              /********************Aqui inicializamos la lcd**********************/


comando:
      move.b #$00,d0
      move.b d0,PTCD          // ponemos rs en 0 para comando
      move #config, A0        // A0 apunta a lo que esta en config
      move #6,d2              //ponemos 6 en d2 para utilizarlo como referencia del comando que hay en el main          
      bsr escribe_lcd         //  vamos a escribir el comando en la lcd

escribe_lcd:
   
      move.b (A0)+,d0         // lo que esta en A0 se mueve a d0
      move.b d0, PTHD         // despues al puerto de los pines de salida que van a mandar dato, los primeros cuatro bits

      move.b #%01000000,d1    //pasamos a registro lo que activa enable
      move.b d1,PTCD          // ACTIVAMOS ENABLE

   move.b #0, d4  
   bsr delay_20               // VAMOS AL DELAY DE 20ms
   
      move.b #000000,d3
      move.b d3,PTCD          // ponemos enable en 0
      lsl.l #4,d0             //rotamos para que llegue la segunda parte, pues usamos 4 bits
      move.b d0,PTHD          // mandamos los otros cuatro bits
      move.b d1, PTCD         // volvemos a activar enable

   move.b #0, d4
   bsr delay_20                //vamos a delay de 20ms

      move.b d3,PTCD           //ponemos enable  en 0          
      subi.l #1,d2             // le restamos uno a d2 para contar que ya ingresamos el primer comando
      cmpi.l #0,d2             // comparamos cero con d2 para ver si ya termino
      bne escribe_lcd          // si aun faltan comandos regresar a escribe_lcd

              /**************si es igual 0 con d2 brincamos a escribir datos, lo que queremos ver en la lcd ***/

dato:

      movea #msg1, A0          // A0 apunta a lo que esta en msg1 que es la palabra hola
      move.b #4,d2             // ponemos un 4 en d2

                               // pasamos a escribe_lcd1

escribe_lcd1:              
      move.b #%10000000,d0    
      move.b d0, PTCD          // ponemos rs en 1 porque estamos escribiendo datos y enable se mantiene en 0
      move.b (A0)+, d1         //movemos lo que esta en A0 a D1
      move.b d1, PTHD          // pasamos a los puertos la primer parte de la letra
      move.b #%11000000,d4
      move.b d4, PTCD          // activamos enable

   move.b #0, d4
   bsr delay_20                // vamos a dalay de 20ms

      move.b d0,PTCD           // dejamos rs en 1 y enable lo mandamos a 0
      lsl.l #4,d1              // rotamos pra poner la segunda parte de la letra
      move.b d1,PTHD           //mandamos la segunda parte de la letra al puerto de salida
      move.b d4, PTCD          // ponemos enable en 1
   
   move.b #0, d4
   bsr delay_20                // brincamos al delay de 20ms

      move.b d0,PTCD           //pasamos enable a 0 y rs se mantiene en 1
      subi.l #1,d2             // le restamos 1 a d2 para saber que ya pasamos la letra
      cmpi.l #0,d2             //comparamos 0 con d2 para ver si ya termino y si no termino regresamos a escribe_lcd1
      bne escribe_lcd1
  bra _main

          /********************************** Aqui va el delay *********************************/
      /***este delay es de 20 milisegundos, esta hecho para la lcd que yo necesite, dependiendo del delay que ustedes necesitan ajustan el numero de lineas de codigo, este micro hace una instruccion en un microsegundo es por eso que comparo el 6667 para que en tres lineas sean aprox 20 milisegundos**/                        
delay_20:
      addi.l #1,d4
      cmpi.l #6667,d4
       bne delay_20
   

rts
Publicado por en No hay comentarios:

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:
Suscribirse a: Entradas (Atom)