Electronica Libre

NOTA: Los programas realizados en este tutorial estan en el siguiente enlace.

http://www.mediafire.com/?ydb5y3b6e3ljutg

Si bien no voy a dar ejemplos complejos ni voy a utilizar el 100% del micro, voy a tratar este tema en funcion a un microcontrolador (MCU) de la familia PIC de la empresa

Microchip.Microcontrolador PIC16F84AEstudiaremos el PIC16F84A ya que es el mas común, mas accesible y mas fácil de programar pos su simplisidad de registros y configuraciones. Claro que los hay con mas o menos pines, con mas o menos preestaciones y de distintos precios, pero para comenzar es el mas estable.Descripción del microcontrolador PIC16F84A
(No entrare en detalles muy profundos por el solo echo de que la guia sirva a todo el publico.)
a. 35 instrucciones.
b. Clock externo que puede ser en RC (con circuito RC) o XT con un cristal de hasta 4MHz (en su modo normal).
c. Memoria Flash de 1024 direcciones por 14 bit de palabra (aquí ira el programa).
d. Memoria Ram de 64bytes (datos que se usaran alojar valores en variables del programa).
e. Memoria EEPROM de 64bytes (para alojar datos que queramos que no desaparezcan tras el reinicio del MCU).
f. ALU de 8bits (el ALU es la unidad aritmética y lógica, que se encarga de las operaciones numéricas).
g. Interrupciones por el pin INT/RB0, por el temporizador TMR0, por OVERFLOW de la EEPROM y por cambio de estado en los pines RB4 a RB7.
h. 1000000 de ciclos de lectura y escritura de la EEPROM, y una retención de datos por 40 años.
i. 13 pines de entrada y salida con el exterior.
j. Dos puertos de E/S PORTA 5 bit y PORTB 8bit.
k. Un contador / temporizador de 8bit llamado TMR0.
l. Características Electricas: Temp de -55°C to +125°C. Tensión de alimentacion 5V.
Máxima corriente del PORTA 50mA. Máxima corriente del PORTB 100mA.

Principios de ensamblador
En esta guia vamos a aprender lo que es el lenguaje ensamblador o Assembler, con la finalidad de poder comprender la lógica que posee y llegar a desarrollar algunos programas sencillos.
Cada microcontrolador posee su set de instrucciones distinto, la diferencia esta en el fabricante, osea el set de instrucciones de un microcontrolador de la marca Freescale (motorola) “MC”, no es igual a el de AVR (Atmel) “AT” o al de Microchip “PIC”, los microcontroladores que vamos a ver en esta guia son de la firma Microchip y se eligió este en particular porque tiene el set de instrucciones mas chico de todos (solo 35 instrucciones para la linea de 8bit).A continuación mostrare un cuadro con las instrucciones del PIC.

Una vez que tenemos en cuenta las instrucciones que el pic maneja, tenemos que tener en cuenta que todos esos pines que tiene que son bidireccionales por ende entrada salida, y los tipos de clock que soporta y las demás configuraciones, deben configurarse para que el microcontrolador pueda saber que es lo que queremos que haga y como queremos que lo haga.
Primero en el programa tenemos que decirle al compilador que micro queremos usar y la librería de donde va a tomar las instrucciones del pic, para ello se escriben las primeras dos lineas de programa dejando una tabulación de espacio:

LIST P=16F84A INCLUDE

Para ello en el encabezado del programa se escriben una serie de caracteres que indican el tipo de reloj que vamos a usar, si vamos a usar el perro guardián (nos avisa cuando se cuelga el programa), la protección de código, y por ejemplo el delay que hay tras el encendido para que no se genere un pico de tensión que cause disparos erráticos.
esa linea seria asi:

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

Luego se pondrán las variables a utilizar con la instrucción EQU que significa Equal o igual, aquí se puso la dirección hexadecimal 30 y 31 solo porque se me ocurrió esa pero es para hacer referencia a un punto de memoria. es solo para definir variables. hay otras formas pero son mas abansadas.

PEPE   EQU    0x30
PEPA   EQU    0x31

Luego de esto comenzamos el programa, donde debemos decirle al micro que empesara ahi, para ello le vamos a poner la instruccion:

ORG 0

Esta instruccion nos dice que el orgien del programa (ORG) es en la posicion cero de la memoria (0) tambien se puede poner en hexadecimal que seria 0x00, o en otras bases pero lo mas comun son esas dos.Seguido de esta instruccion debemos configurar los puertos del micro.

       bsf    STATUS,RP0
clrf   TRISB
clrf   TRISA
bcf    STATUS,RP0

Aqui aparecen tres instrucciones nuevas, los nombres de los dos puertos y el estatus que va a configurar el micro.
Seria instruccion (BSF) que esto significa BitSetF que quiere decir que va a setear (poner a 1) el bit de F (F es el valor que toma la variable, en este caso la variable es RP0, que esta alojada en un conjunto de variables que se llama STATUS) por ende RP0 va a valer 1. STATUS tiene 8 bits donde el RP0 equivale al bit numero 5 osea graficamente seria STATUS = 00001000.
luego aparece la instruccion (CLRF) esto es clear f, osea borra el contenido de f, mas tecnicamente lo pone a cero. en este caso va a poner TRISB (todo su contenido) a cero, como TRISB es el registro del PORTB osea los 8 pines del integrado del puerto b, que si estan a 1 son entradas y a 0 son salidas. en este caso al decir que borre todo TRISB poner los 8 bit a cero, osea
TRISB = 00000000, por ende seran todas salidas. si quisiera que sean entradas tendrian qeu ser 11111111 o pueden ser mixtos osea 11001100 por ejemplo. pero la instruccion CLRF ya no nos serviria porque esa solo pone a cero toda la variable.
Ahohra se repite lo mismo pero con TRISA, osea el registro de PORTA que tambien lo pone a ceros, por ende tambien son salidas.
Una vez echo esta configuracion aparece STATUS,RP0 pero con la instruccion (BCF) que es BitClearF, osea (poner a 0), ahora RP0 = 0, y STATUS = 00000000. con esto decimos que salimos de la config, osea fijencen que primero entramos a la configuracion, luego configuramos y luego salimos de la configuracion.
Ahora empesamos el programa propiamente dicho, que en nuestro caso sera encender leds a la salida del puerto B, para ello vamos a escribir:

MODDEAR

MOVLW   b’01010101’      MOVWF   PORTB
GOTO    MODDEAR

Notese que aparecen tres instrucciones, MOVLW, MOVWF y GOTO.MOVLW es mover el literal a W (donde W es la memoria RAM), MOVWF es mover de W (osea donde movimos antes) a F que era como habiamos dicho antes el bit del registro en este caso nos refermios a PORTB y por ultimo GOTO que es “ir a”.
Entonces leemos esto, primero aparece un MODDEAR en la primer linea, esto es una etiqueta que puede tener cualquier nombre, hace referencia a un punto en el programa. luego con una tabulacion de espacio aparece MOVLW y luego con otra tabulacion de espacio aparece b’01010101’ esta linea dice mover a W el literal, el literal es b’01010101’ que significa la letra b que hablamos en binario (podria ser h de hex, d de decimal, o de octal, etc..) pero usamos vinario porque es mas visible el led que va a encender es el que tiene el 1 y el que va a quedar apagado es el que tiene 0, entonces va a mover 01010101 a W (que era la ram).
en el siguiente renglon mediante un espacio de tabulacion aparece MOVWF y otra tabulacion mas y aparece PORTB, aca va a mover el contenido de W al PORTB, recordemos que antes le movimos 01010101 a W, asique va a mover eso a PORTB y ahora PORTB tiene 01010101, como PORTB hace referencia al puerto del pic (puerto fisico “las patitas”) los leds que esten ahi van a encender o permaneces apagadaos segun ese numero binario.
Por ultimo aparece mediante una tabulacion el GOTO y en otra tabulacion el MODDEAR, esto quiere decir que va a saltar a la etiqueta MODDEAR que estaba puesta arriba, que quiere decir esto que el programa entra en LOOP osea que hace ciclicamente esto todo el tiempo.
Ahora para terminar el programa necesitamos decirle, que termina y para ello ponermos la instruccion:

END

Aqui temrino todo, solo resta compilar este programa con el MPASM de Microchip (es gratis y se descarga de la pagina) y esto nos genera una serie de archivos que son archivos de registros, de logs, de comentarios y el que nos interesa el *.HEX que es el codigo que se va a leer en el pic, bueno este ultimo archivo lo va a crear si es que el programa no tiene errores, sino no lo crea y habra que corregir el codigo.Una vez que tengamos este archivo solo tenemos que grabar el pic y para ello podemos usar cualquier programa con cualquier interface por ejemplo el ICPROG (gratis) y el programador JDM por puerto Serial.Solo resta grabar el pic y listo para conectarle los leds, el cristal y alimentarlo con 5V.

El programa:

;*************** PROGRAMA PARA ENDENDER LEDS POR EL PUERTO B********************** ;**      Powered by MODDEAR  ;los espacios entre instrucciones y literales se hacen con tabulaciones, no con espacios. ;los comentarios pueden ir despues de un punto y coma.

LIST P=16F84A

INCLUDE     __CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC  PEPE     EQU       0x30               ; Declaracion de la variable PEPE PEPA     EQU       0x31               ; Declaracion de la variable PEPA

ORG       0                  ; Origen del programa en la posicion cero

         bsf       STATUS,RP0         ; Se entra a la configuracion de puertos                                           ; poniendo a uno el bit RP0 de STATUS         clrf      TRISB              ; Se pone a cero el registro TRISB, de esta                                           ; forma se

transforman en salidas
  clrf      TRISA              ; Se pone a cero el registro TRISA, de esta                                        ; forma se transforman en salidas
  bcf       STATUS,RP0         ; Se sale de la configuracion de puertos                                             ; poniendo a cero el bit RP0 de STATUSMODDEAR                               ; Etiqueta MODDEAR
 MOVLW   b’01010101’           ; Mueve 01010101 a W
 MOVWF   PORTB                 ; Mueve el contenido de W (01010101) a PORTB

GOTO MODDEAR

               ; (se visualisa en la salida)
                               ; Salta a la etiqueta MODDEAR        END                           ; Fin del programa

El circuito seria el siguiente:

Ahora usando el mismo circuito vamos a hacer que prendan y apagen a una velocidad visible.

;*************** PROGRAMA PARA ENDENDER LEDS POR EL PUERTO B INTERMITENTES**********************

;**      Powered by MODDEAR;Para que se logre que sean intermitentes debemos crear una demora, sabemos que el micro esta funcionando a
;4MHz (cada instruccion consume 4 ciclos por ende la velocidad real es de 1MHz) entonces tendriamos que bajar
; velocidad porque ver un led prender y apagar a 1MHz es impiosible, entonces para que sea vicible por ejemplo cada 0,5s
; vamos a hacer una demora, osea vamos a hacer perder tiempo al micro, como logramos esto, haciendo que el micro pase; por una instruccion determinada cantidad de veces y despues siga con el programa, la cantidad de veces que pase por esa
; instruccion determina el tiempo que pierde, por ende la demora.

LIST    P=16F84A
INCLUDE    

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

PEPE   EQU   0x30      ; Declaracion de la variable PEPE
PEPA   EQU   0x31      ; Declaracion de la variable PEPA
 ORG    0            ; Origen del programa en la posicion cero

bsf    STATUS,RP0         ; Se entra a la configuracion de puertos poniendo a uno el bit RP0 de STATUS
clrf    TRISB         ; Se pone a cero el registro TRISB, de esta forma se transforman en salidas
 clrf    TRISA         ; Se pone a cero el registro TRISA, de esta forma se transforman en

salidas
bcf    STATUS,RP0         ; Se sale de la configuracion de puertos poniendo a cero el bit RP0 de STATUS

MODDEAR            ; Etiqueta MODDEAR
MOVLW   b’01010101’      ; Mueve 01010101 a W
MOVWF   PORTB         ; Mueve el contenido de W (01010101) a PORTB (se visualisa en la

salida)
MOVLW   b’10101010’      ; Mueve 10101010 a W
MOVWF   PORTB         ; Mueve el contenido de W (10101010) a PORTB (se visualisa en la salida)
CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
GOTO    MODDEAR      ; Salta a la etiqueta MODDEARDEMORA               ; Etiqueta DEMORA
MOVLW   150         ; Movemos el numero 150 decimal a W
MOVWF   PEPE         ; Movemos el contenido de W a la variable PEPE
UNO   DECFSZ   PEPE         ; Etiqueta UNO, Decrementamos PEPE
GOTO   UNO         ; Va hacia la etiqueta UNO, va a hacer este loop hasta que PEPE sea Cero
RETURN             ; Una vez que PEPE sea cero, se saltea la  instruccion GOTO UNO y va a                      ; RETURN  , con la  instruccion RETURN, retorna donde se llamo anteriormente
          ; osea vuelve a el CALL DEMORA y sigue con el Programa osea la  instruccion                   ; siguiente que es GOTO MODDEAR.

END            ; Fin del programa

En este programa aparecen tres instrucciones mas, el CALL, RETURN y DECFSZ, el CALL como lo dice la palabra llama, en este caso a una etiqueta que tenga el mismo nombre, una vez que se ejecuta el llamado a esa etiqueta, se ejecuta la sub rutina que tiene esa etiqueta (en nuestro caso la sub rutina DEMORA) una vez que la subrutina llega a su fin aparece la instruccion RETURN que no hace mas que retornar hacia el punto en donde fue llamada la subrutina, osea vuelve al programa principal justo a la instruccion siguiente al CALL, en nuestro caso a GOTO MODDEAR.
La instruccion DECFSZ significa Decrement F Skip Z, donde F es la variable a decrementar osea PEPE, y Z en el pic es un Flag osea una bandera que esta a 1 o a 0 avisandonos algo, en este caso nos avisa cuando F sea igual a 0, osea como esta instruccion es Decrementar, se entiende que va a ir decrementando de a uno el numero que tiene PEPE, osea cuando pase por ahi va a tener 150, cuando vuelva a pasar por ahi va a tener 149, y asi hasta el cero, y cuando sea cero, el bit Z va a tener un 1 y ahi se producir el Skip osea el “salto” de instruccion.
Resumiendo va a decrementar PEPE hasta que sea cero y cuando sea cero va a saltar una instruccion, ya que mientras no sea cero va a ir a la instruccion que le sige GOTO UNO y cuando sea cero va a saltar esa instruccion y va a ir directamente a RETURN.
Algunas instrucciones consumen un siclo de reloj y otras dos, por ejemplo el CALL, GOTO, RETURN consumen dos ciclos.
cada instruccion normal consume 1us espeto esas que consumen 2us, por ende si pasamos 150 veces por ahi vamos a tener
2 del CALL va a pasar 1 vez -----------------> 2
1 del MOVLW va a pasar 1 vez -----------------> 1
1 del MOVWF va a pasar 1 vez -----------------> 1
1 del DECFSZ va a pasar 150 veces -----------> 150 255
2 del GOTO va a pasar 1 vez -----------------> 300 510
2 del RETURN va a pasar 1 vez -----------------> 2
158us, osea que va a demorar 456 micro segundos 0,000456s cosa que no vamos a notar... asique deveriamos demorar mas, si ponemos 255 (que es 11111111 por ende el numero maximo ya que es un micro de 8 bit) va a ser una demora 771us osea 0,000771, bueno aca tampoco lo vamos a notar., entonces no nos queda otro que usar un DECFSZ mas, pero vamos a usar uno adentro del otro, osea el primer DECFSZ va a contar las veces que va a pasar el segundo DECFSZ que a su vez va a contar un numero., seria:

DEMORA               ; Etiqueta DEMORA
MOVLW   150         ; Movemos el numero 150 decimal a W
MOVWF   PEPE         ; Movemos el contenido de W a la variable PEPE
MOVLW   150         ; Movemos el numero 150 decimal a W   MOVWF   PEPA         ; Movemos el contenido de W a la variable PEPA
UNO   DECFSZ   PEPE         ; Etiqueta UNO, Decrementamos PEPE
GOTO   UNO         ; Va hacia la etiqueta DOS, va a hacer este loop hasta que PEPE sea Cero
DOS   DECFSZ   PEPA         ; Etiqueta DOS, Decrementa PEPA hasta que sea cero
GOTO   UNO         ; Va hacia la etiqueta UNO para repetir el LOOPRETURN            ; Retorna a al programa

Osea va a decrementar el LOOP UNO hasta que se haga cero una vez que se hace cero decrmentea solo 1 en el LOOP DOS y vuelve a decrementar los 150 del LOOP UNO, ahi decrementea otro mas en el LOOP DOS y vuelve a dec los 150 del LOOP UNO entonces se podria decir que seria 150 por 150.
Entonces el calculo de tiempo aca seria.
2 del CALL va a pasar 1 vez -----------------> 2
1 del MOVLW va a pasar 1 vez -----------------> 1
1 del MOVWF va a pasar 1 vez -----------------> 1
1 del MOVLW va a pasar 1 vez -----------------> 1
1 del MOVWF va a pasar 1 vez -----------------> 1
1 del DECFSZ va a pasar 150 veces -----------> 1502 del GOTO va a pasar 1 vez -----------------> 300
1 del DECFSZ va a pasar 150 veces -----------> 150 255
2 del GOTO va a pasar 1 vez -----------------> 300 510
2 del RETURN va a pasar 1 vez -----------------> 2
Pero la diferencia es que dentro de un LOOP hay otro LOOP por lo que seria una multiplicacion entre 450 * 450 + 8 = 202ms osea 0,202s pero podriamos demorarlo mas para que se vea mas facil. y poner a PEPA 255 y a PEPE 255 nos daria 585ms osea 0.58s ahi ya es visible la velocidad por ende nos quedaria un programa de la siguiente manera.

;*************** PROGRAMA PARA ENDENDER LEDS POR EL PUERTO B INTERMITENTES**********************;**      Powered by MODDEAR
;Para que se logre que sean intermitentes debemos crear una demora, sabemos que el micro esta funcionando a
;4MHz (cada instruccion consume 4 ciclos por ende la velocidad real es de 1MHz) entonces tendriamos que bajar ; velocidad porque ver un led prender y apagar a 1MHz es impiosible, entonces para que sea vicible por ejemplo cada 0,5s
; vamos a hacer una demora, osea vamos a hacer perder tiempo al micro, como logramos esto, haciendo que el micro pase
; por una instruccion determinada cantidad de veces y despues siga con el programa, la cantidad de veces que pase por esa; instruccion determina el tiempo que pierde, por ende la demora.

LIST    P=16F84A
INCLUDE    

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

PEPE   EQU   0x30      ; Declaracion de la variable PEPE
PEPA   EQU   0x31      ; Declaracion de la variable PEPA

ORG    0            ; Origen del programa en la posicion cero
bsf    STATUS,RP0         ; Se entra a la configuracion de puertos poniendo a uno el bit RP0 de STATUS
clrf    TRISB         ; Se pone a cero el registro TRISB, de esta forma se transforman en salidas
 clrf    TRISA         ; Se pone a cero el registro TRISA, de esta forma se transforman en salidas
bcf    STATUS,RP0         ; Se sale de la configuracion de puertos poniendo a cero el bit RP0 de STATUS

MODDEAR            ; Etiqueta MODDEAR
MOVLW   b’01010101’      ; Mueve 01010101 a WMOVWF   PORTB         ; Mueve el contenido de W (01010101) a PORTB (se visualisa en la salida)
CALL    DEMORA               ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW   b’10101010’      ; Mueve 10101010 a W
MOVWF   PORTB         ; Mueve el contenido de W (10101010) a PORTB (se

visualisa en la salida)
CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
GOTO    MODDEAR      ; Salta a la etiqueta MODDEAR

DEMORA               ; Etiqueta DEMORA de 0.58 segundos
MOVLW   255         ; Movemos el numero 150 decimal a W
MOVWF   PEPE         ; Movemos el contenido de W a la variable PEPE
MOVLW   255         ; Movemos el numero 150 decimal a W
MOVWF   PEPA         ; Movemos el contenido de W a la variable PEPA
UNO   DECFSZ   PEPE         ; Etiqueta UNO, Decrementamos PEPE
GOTO   UNO         ; Va hacia la etiqueta DOS, va a hacer este loop hasta que PEPE sea CeroDOS   DECFSZ   PEPA         ; Etiqueta DOS, Decrementa PEPA hasta que sea cero
GOTO   UNO         ; Va hacia la etiqueta UNO para repetir el LOOP
RETURN               ; RETURN  , con la instruccion RETURN, retorna donde se llamo anteriormente
          ; osea vuelve a el CALL DEMORA y sigue con el Programa  osea la instruccion                   ; siguiente que es GOTO MODDEAR.END            ; Fin del programa

De esta misma forma podemos hacer mas secuencias como se imaginaran en este progama tenemos dos secuencias

MOVLW    b’01010101’      ; Mueve 01010101 a W
MOVWF   PORTB         ; Mueve el contenido de W (01010101) a PORTB (se visualisa en la salida)
CALL    DEMORA               ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW   b’10101010’      ; Mueve 10101010 a W
MOVWF   PORTB         ; Mueve el contenido de W (10101010) a PORTB (se visualisa en la salida)
CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
GOTO    MODDEAR      ; Salta a la etiqueta MODDEAR
Pero pdroan ser mas
MOVLW    b’00000011’      ; Mueve 00000011a W
MOVWF   PORTB         ; Mueve el contenido de W (00000011) a PORTB (se visualisa en la salida)
CALL    DEMORA               ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW   b’00001100’      ; Mueve 00001100 a W
MOVWF   PORTB         ; Mueve el contenido de W (00001100) a PORTB (se visualisa en la salida)CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW    b’00110000’      ; Mueve 00110000 a W
MOVWF   PORTB         ; Mueve el contenido de W (00110000) a PORTB (se visualisa en la salida)
CALL    DEMORA               ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW   b’11000000’      ; Mueve 11000000 a W
MOVWF   PORTB         ; Mueve el contenido de W (11000000) a PORTB (se visualisa en la salida)CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
GOTO    MODDEAR      ; Salta a la etiqueta MODDEAR

Por el codigo que se ve ahi, nos damos cuenta que la secuencia que se va a ver en los leds es que se van a ir moviendo de a dos de derecha a izquierda y lugeo otra vez.
El codigo de saldia seria

0 - 00000011
1 - 00001100
2 - 00110000
3 - 11000000

Bueno les dejo la idea, por ejemplo para hacer un POV “Persisten of Vision” osea eso que se pone en los fanes y escribe cuando gira, pueden hacerlo con este programa (claro no es la forma mas optima de hacerlo ya que hay instrucciones mas dedicadas para tener menos codigo pero igual es valida esta forma y facil de comprender).
Ejemplo para poner una letra “A” van a tener que hacerla con unos y ceros., pero de costado ya que los leds estan de costado

Salidas del PORTB       CARACTER “A”        SIMPLIFICANDO PARA QUE SE VEA

0         00000    
1      01110        111
2      10001      1      1
3      10001      1      1
4      11111      11111
5      10001      1      1
6      10001      1      1
7      10001      1      1

en nuestro porgrama seria

MOVLW    b’11111110’      ; Mueve 11111110 a W
MOVWF   PORTB         ; Mueve el contenido de W (11111110) a PORTB (se visualisa en la salida)
CALL    DEMORA               ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW   b’00010001’      ; Mueve 00010001 a W
MOVWF   PORTB         ; Mueve el contenido de W (00010001) a PORTB (se visualisa en la salida)
CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW   b’00010001’      ; Mueve 00010001 a W
MOVWF   PORTB         ; Mueve el contenido de W (00010001) a PORTB (se visualisa en la salida)
CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continuaMOVLW   b’00010001’      ; Mueve 00010001 a W
MOVWF   PORTB         ; Mueve el contenido de W (00010001) a PORTB (se visualisa en la salida)
CALL    DEMORA         ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
MOVLW    b’11111110’      ; Mueve 11111110 a W
MOVWF   PORTB         ; Mueve el contenido de W (11111110) a PORTB (se visualisa en la salida)
CALL    DEMORA               ; Llama a DEMORA y una vez que DEMORA termine su rutina vuelve y continua
GOTO    MODDEAR      ; Salta a la etiqueta MODDEAR

Lo unico a tener en cuenta es que la velocidad tiene que ser mas rapida que 0.58s por ende ahi tiene que jugar con los valores de PEPE y PEPA y listo nuestro POV con la letra A, si quieren pueden pnoer espacios para que si van a poner mas de una letra no esten pegadas, los espacios son leds apagados asique seria mover b’00000000’ o hacer CLRF a PORTB que iria entre letra y letra.

;*************** POV***************
;**    Powered by MODDEAR
; Programa para realizar un POV con la palabra HOLA.

LIST    P=16F84A
INCLUDE    

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

PEPE    EQU       0x30              ; Declaracion de la variable PEPE
PEPA    EQU       0x31             ; Declaracion de la variable PEPA
         ;
ORG       0                   ; Origen del programa en la posicion cero               ;
bsf       STATUS,RP0               ; Se entra a la configuracion de puertos poniendo a uno el bit RP0 de STATUS
clrf    TRISB               ; Se pone a cero el registro TRISB, de esta forma se transforman en salidas
  clrf    TRISA               ; Se pone a cero el registro TRISA, de esta forma se transforman en salidas
  bcf      STATUS,RP0               ; Se sale de la configuracion de puertos poniendo a cero el bit RP0 de STATUS
         ;
MODDEAR
MOVLW   b'11111111'           ;   LETRA H
MOVWF   PORTB               ;            11111111   CALL   DEMORA               ;               1
MOVLW   b'00010000'           ;               1
MOVWF   PORTB               ;               1
CALL   DEMORA               ;            11111111
MOVLW   b'00010000'           ;
MOVWF   PORTB               ;                     1       1
CALL   DEMORA               ;                   1       1
MOVLW   b'00010000'           ;                   1       1
MOVWF   PORTB               ;                     1       1
CALL   DEMORA                  ;                      1 1 1 1 1
MOVLW   b'11111111'           ;                      1       1
MOVWF   PORTB               ;                     1       1
CALL   DEMORA               ;                     1       1   CLRF   PORTB               ;  -------------------------- ESPACIO -------------------------------------------
CLRF   PORTB               ;  -------------------------- ESPACIO -------------------------------------------
CALL   DEMORA          ;
MOVLW   b'01111110'           ;   LETRA O   MOVWF   PORTB               ;            111111
CALL   DEMORA         ;           1      1
MOVLW   b'10000001'           ;           1      1
MOVWF   PORTB               ;           1      1
CALL   DEMORA               ;            111111
MOVLW   b'10000001'           ;
MOVWF   PORTB               ;                          1 1 1
CALL   DEMORA               ;                  1       1
MOVLW   b'10000001'           ;                   1       1
MOVWF   PORTB               ;                   1       1
CALL   DEMORA               ;                   1       1
MOVLW   b'01111110'           ;                  1       1
MOVWF   PORTB               ;                       1       1   CALL   DEMORA                  ;                     1 1 1
CLRF    PORTB                ;  -------------------------- ESPACIO -------------------------------------------
CLRF   PORTB               ;  -------------------------- ESPACIO -------------------------------------------
CALL   DEMORA          ;
MOVLW   b'11111111'           ;  LETRA L
MOVWF   PORTB               ;         11111111
CALL   DEMORA               ;         1
MOVLW   b'10000000'           ;         1
MOVWF   PORTB               ;         1                  1
CALL   DEMORA               ;                            1
MOVLW   b'10000000'           ;                            1   MOVWF   PORTB               ;                            1
CALL   DEMORA               ;                            1
MOVLW   b'10000000'           ;                            1
MOVWF   PORTB              ;                            1
CALL   DEMORA                  ;                            1 1 1 1
CLRF    PORTB               ;  -------------------------- ESPACIO -------------------------------------------
CLRF   PORTB               ;  -------------------------- ESPACIO -------------------------------------------
CALL   DEMORA          ;
MOVLW   b'11111110'           ;  LETRA A
MOVWF   PORTB               ;          1111111
CALL   DEMORA                  ;             1   1   MOVLW   b'00010001'           ;             1   1
MOVWF   PORTB               ;             1   1
CALL   DEMORA               ;          1111111
MOVLW   b'00010001'           ;
MOVWF   PORTB               ;
CALL   DEMORA               ;                              1 1 1
MOVLW   b'00010001'           ;                            1       1
MOVWF   PORTB               ;                            1       1
CALL   DEMORA               ;                            1 1 1 1 1
MOVLW   b'11111110'           ;                            1       1
MOVWF   PORTB               ;                            1       1
CALL   DEMORA                  ;                            1       1
CLRF    PORTB                ;  -------------------------- ESPACIO

-------------------------------------------
CLRF    PORTB                ;  -------------------------- ESPACIO -------------------------------------------
CALL   DEMORA                  ;
GOTO   MODDEAR              ; Vuelve a la etiqueta MODDEAR
         ;
DEMORA   MOVLW   .10
MOVWF   PEPA
UNO   MOVLW   .60
MOVWF   PEPE
DOS     DECFSZ   PEPE
GOTO   DOS
DECFSZ   PEPA
GOTO   UNO      RETURN
         ;
END                      ; Fin del programa

Este codigo se debe hacer en el block de notas de windows o cualqueir otro editor de texto plano, en donde vamos a setear courier new para que se respeten los espacios de caracteres y las tabulacions, y vamos a codificar, no hay que olvidarse que cada espacio entre codigo se hace con la telca TAB en lugar de ESPACE, y los comentarios son despues del “ ; ”.
Una vez codificado todo se guarda como *.asm (es la extencion que pertenece al assembler).

Ahora vamos a proceder a ir al Compilador MPASM

Luego tras la ejecucion de ese programa nos aparecera la ventana para buscar el programa POV.asm (los seteos estan asi por defecto y no es necesario cambiar nada).

Luego de esto vamos a presionar el boton Assemble y nos mostrara una ventana de compilacion con una barra de progreso, que si el codigo esta bien echo debe verse de la siguiente manera.

Luego nos creara 4 archivos en el mismo lugar donde estaba el programa, que seran POV.COD, POV.LST, POV.ERR y POV.HEX,
solo nos interesara el POV.HEX ya que es el que tenemos que usar para el programa que cargara el microcontrolador, (en el caso de que no nos de la compilacion satisfactoria no nos creara el POV.HEX pero tendremos que entrar al POV.ERR para ver los errores que tenemos.
Ahora mostrare como se ve el codigo en Hexadecimal para transferir al PIC.

Ahora solo falta usar un programa para transferiri que va a depender del hardware de interface que se use, por ejemplo, ICPROG, PONYPROG, WINPIC, UPP628, IDC2, etc... y el Hardware de intefdace que puede ser por puerto LPT, o SERIAL o USB.

NOTA: me costo un poco subir el codigo porque se desordena un poco, igualmente aca les subo el .asm por si les interesa hacerlo o verlo bien.

http://www.mediafire.com/?ydb5y3b6e3ljutg