Un display de 7 segmentos no es otra cosa que 7 leds conectados entre si con su ánodo o su cátodo en común. Dependiendo del tipo de display será la manera en que se enciendan sus segmentos, un display de cátodo común requiere un 1 logico para encender mientras que uno de cátodo común un 0 así que dependiendo del display que se utilice cambiará la rutina encargada de controlarlo, pero en cualquier caso al momento de cambiar el tipo de display solo debemos cambiar los ceros por unos y viceversa.

Aqui supondremos que se usa un display de cátodo común así que los segmentos encenderán con un 1. El display estará conectado al puerto B, el segmento A estará conectado al bit RB0, el B al RB1, el C al RB2, el D al RB3 y así sucesivamente hasta llegar al G que estará conectado al bit RB6.

Encender y apagar los segmentos del display es igual que encender y apagar leds, podríamos hacerlo de la misma manera que en el tutorial 1, pero una manera mas eficaz de controlar un display es mdiante una tabla. Haremos que el display muestre los números 0 a 15 en hexadecimal (0 a F) con un retardo de medio segundo entre cada número. Para eso se declara el puerto B como salida. Una vez hecho eso se crea la rutina encargada de mandar llamar el numero correspondiente de una tabla y de desplegar el numero correspondiente por el puerto B. El programa principal es el siguiente:

Y ese es basicamente el programa. Al principio se declaran 4 variables, una se utiliza para llevar la cuenta del numero a desplegar y las demas sirven para la rutina de retardo. Como ya se dijo se configura el puerto B como salida y despues se limpia la variable Numero (clrf NUMERO). Despues el programa entra en una subrutina que se encarga de leer la tabla y de desplegar el numero en el puerto. Primero se mueve el valor de la variable Numero al registro W (movf NUMERO,w) y despues se manda llamar la tabla (call DESPLIEGA), al volver el registro W tiene el valor del numero a desplegar y simplementa se mueve al puerto B (movwf PORTB). Se llama a la rutina de retardo (call RETARDO) y al volver de esta se incrementa el valor de la variable Numero (incf NUMERO,f) y despues se transfiere ese valor al registro W (movf NUMERO,w). Esto se hace para realizar una comparacion entre W y la literal 0×10 (16 en valor decimal) para saber si la variable Numero ya fue incrementada 16 veces, si es asi se salta la siguiente instruccion y el programa se repite desde la etiqueta Principal, si no es asi el programa regresa a la etiqueta Ciclo. De este modo el numero se incrementa de 0 a F y al llegar a F regresa a 0. La comparacion se realiza mediante la instruccion sublw 0×10 si el resultado es cero (en caso de que NUMERO=16) la bandera ZERO se pone en 1 y es esa la bandera que se revisa en btfss STATUS,Z.

Como ya se dijo antes de llamar la rutina que lee la tabla se carga el valor de la variable Numero en W, esto se hace asi ya que al entrar a la rutina se realiza una suma entre W y el contador de programa PCL para montarlo en un offset, asi el contador apuntara a la direccion que seguia mas el valor de la variable Numero. Asi la rutina de la table queda de la siguiente manera:

Y asi, de este modo se decodifica un display de 7 segmentos. La rutina de retardo se omitio en la explicacion ya que los retardos se explicaron anteriormente, de cualquier forma se incluye en el codigo del programa. Descargar codigo.

Como nota final: Las imagenes que contienen el codigo en esta ocasion se ven algo distintas que en los tutoriales pasados, ese descuadre se debe a que el codigo se escribio utilizando MPLAB bajo linux, pero en realidad se conservan los mismos espacios y tabulaciones que en ocasiones anteriores, eso se puede ver al descargar el codigo completo.

La semana pasada se hablo sobre el conjunto de instrucciones de la gama media de los micrcocontroladores PIC y se explicaron 34 de las 35 que lo forman. Solamente 34 ya que una paso totalmente desapercibida, se trata de MOVWF asi que ahora a modo de errata se explica esta instruccion perteneciente al grupo de instrucciones orientadas a registros.

MOVWF: Mover el valor del registro W al registro f
El contenido del registro ‘W’ se mueve al registro ‘f’.
Sintaxis: [etiqueta] MOVWF f
Flags afectados: Ninguno
Ejemplo: MOVWF REG
Antes de la instrucción: REG=0×03, W=0xA4
Después de la instrucción: REG=0xA4, W=0xA4

Ahora si, con MOVWF ya se explicaron las 35 instrucciones y ya podemos continuar con los ejemplos de programación.

Como ya hemos visto, para que el microcontrolador lleve acabo una tarea, debemos indicarle exactamente que debe hacer, o en otras palabras, debemos escribir el programa que el micro ejecutara. Ya hemos visto varios ejemplos y muchas de las instrucciones del pic, pero ahora veremos las 35 instrucciones del ensamblador mpasm. Estas 35 instrucciones son las mismas para toda la gama media de los microcontroladores pic asi que si mas adelante se quiere realizar un programa para un pic 16F877 se usaran las mismas instrucciones.

Antes de continuar es necesario definir algunos terminos que se usaran para explicar las instrucciones:
f: cualquier registro del microcontrolador
W: registro de trabajo
b: posicion de un bit en el registro ‘f’
d: destino, puede ser ‘f’ (d=1) o ‘W’ (d=0)
etiqueta: grupo de caracteres que marcan el inicio de una parte del programa
[]: opcional
: posicion de un bit dentro de un registro

Instrucciones orientadas a registros

ADDWF: Suma W y f
Suma el contenido del registro ‘W’ y el registro ‘f’. Si “d” es 0, el resultado se almacena en el registro W. Si ‘d’ es 1 el resutado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] ADDWF f,d
Operación: (W) + (f) –> (destino)
Flags afectados: C, DC, Z
Ejemplo: ADDWF REG,1
Antes de la instrucción: W=0×03, REG=0×04
Después de la instrucción: W=0×03, REG=0×07

ANDWF: W AND f
Realiza la operación lógica AND entre el registro W y el registro “f”. Si “d” es 0 el resultado se almacena en el registro W. Si “d” es 1, el resultado se almacena en el registro “f”.
Sintaxis: [etiqueta] ANDWF f,d
Operación: (W) AND (f) –> (destino)
Flags afectados: Z
Ejemplo: ANDWF REG,1
Antes de la instrucción: W=0×17, REG= 0xC2
Después de la instrucción: W=0×17, REG= 0×02

CLRF: Borra un registro
Borra el contenido del registro ‘f’ y se activa el flag Z.
Sintaxis: [etiqueta] CLRF f
Flags afectados: Z
Ejemplo: CLRF REG
Antes de la instrucción: REG=0×54
Después de la instrucción: REG=0×00, Z=1

CLRW: Borra el registro de trabajo W
Borra el contenido del registro ‘W’ y se activa el flag Z. Esta instruccion no tiene operandos.
Sintaxis: [etiqueta] CLRW
Flags afectados: Z
Ejemplo: CLRW
Antes de la instrucción: W=0×54
Después de la instrucción: W=0×00, Z=1

COMF: Complementa el registro f
El contenido del registro ‘f’ se complementa. Si d=0 el resultado se almacena en el registro W. Si d=1 el resultado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] COMF f,d
Flags afectados: Z
Ejemplo: COMF REG,0
Antes de la instruccion: REG=0×13
Después de la instrucción: REG=0×13, W=0xEC

DECF: Decrementa f en 1
De decrementa en uno el contenido del registro ‘f’. Si d=0, el resultado se almacena en W. Si d=1, el resultado se almacena en ‘f’.
Sintaxis: [etiqueta] DECF f,d
Flags afectados: Z
Ejemplo: DEC CONT, 1
Antes de la instrucción: CONT=0×01, Z=0
Después de la instrucción: CONT=0×00, Z=1

DECFSZ: Decrementa en 1 y salta si el resultado es 0
El contenido del registro ‘f’ se decrementa. Si ‘d=0, el resultado se coloca en el registro W. Si d=1, el resultado se coloca en el registro ‘f’. Si el resultado es 0, se salta la siguiente instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] DECFSZ f,d
Flags afectados: Ninguno

INCF: Incrementa el registro f
Incrementa en uno el contenido del registro ‘f’. Si d=0, el resultado se almacena en W. Si d=1, el resultado se almacena en ‘f’.
Sintaxis: [label] INCF f,d
Flags afectados: Z
Ejemplo: INCF CONT,1
Antes de la instrucción: CONT=0xFF, Z=0
Después de la instrucción: CONT=0×00, Z=1

INCFSZ: Incrementa en 1 y salta si el resultado es 0
El contenido del registro ‘f’ se incrementa. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado se coloca en el registro ‘f’. Si el resultado es 0, se salta la siguiente instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] DECFSZ f,d
Flags afectados: Ninguno

IORWF: W OR f
Realiza la operación lógica OR entre el registro W y el registro ‘f’. Si d=0 el resultado se almacena en el registro W. Si d=1, el resultado se almacen en el registro ‘f’.
Sintaxis: [etiqueta] IORWF f,d
Flags afectados: Z
Ejemplo: IORWF REG,0
Antes de la instrucción: REG=0×13, W=0×91
Después de la instrucción: REG=0×13, W=0×93

MOVF: Mover el registro f
El contenido del registro ‘f’ se mueve al destino ‘d’. Si d=0, el destino es el registro W. Si d=1, el destino es el propio registro ‘f’.
Sintaxis: [etiqueta] MOVF f,d
Flags afectados: Z
Ejemplo: MOVF REG,0
Después de la instrucción: W=REG

RLF: Rota el registro f a la izquierda
El contenido del registro ‘f’ se rota una posición a la izquierda. El bit de más peso pasa al carry y el carry se introduce por el bit de menos peso de ‘f’. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’.
Sintaxis: [etiqueta] RLF f,d
Flags afectados: C
Ejemplo: RLF REG,1
Antes de la instrucción: REG=b’11100110′, C=0
Después de la instrucción: REG=b’11001100′, C=1

RRF: Rota el registro f a la derecha
El contenido del registro ‘f’ se rota una posición a la derecha. El bit de menos peso pasa al carry y el carry se introduce por el bit de más peso de ‘f’. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’.
Sintaxis: [etiqueta] RLF f,d
Flags afectados: C
Ejemplo: RLF REG,1
Antes de la instrucción: REG=b’11100110′, C=0
Después de la instrucción: REG=b’01110011′, C=0

SUBWF: Resta f – W
Resta el contenido del registro ‘f’ menos el contenido del registro W. Si d=0, el resultado se almacena en el registro W. Si d=1, el resultado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] SUBWF f,d
Flags afectados: C, DC, Z
Ejemplo: SUBWF REG,1
Antes de la instrucción: REG=0×01, W=0×02
Después de la instrucción: REG=0xFF, W=0×02

SWAPF: Intercambio de f
El nibble bajo del registro ‘f’ se intercambia con el nibble alto del mismo. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’.
Sintaxis: [etiqueta] SWAPF f,d
Flags afectados: Ninguno
Ejemplo: SWAPF REG,1
Antes de la instrucción: REG=0×54
Después de la instrucción: REG=0×45

XORWF: W XOR f
Realiza la función lógica OR exclusiva entre el contenido del registro W y el registro ‘f’. Si d=0, el resultado se almacena en el registro W. Si d=1 el resultado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] XORWF f,d
Flags afectados: Z
Ejemplo: XORWF REG,1
Antes de la instrucción: REG=0xAF, W=0xB5
Después de la instrucción: REG=0×1A, W=0xB5

NOP: No operacion
No realiza ninguna operacion, solo consume un ciclo de reloj
Sintaxis: [etiqueta] NOP

Instrucciones orientadas a bits

BCF: Borra un bit
Borra el bit ‘b’del registro ‘f’
Sintaxis: [etiqueta] BCF f,b
Ejemplo: BCF REG,0
Antes de la instrucción: REG=b’01101101′
Después de la instrucción: REG=b’01101100′

BSF: Activa un bit
Activa el bit ‘b’ del registro ‘f’
Sintaxis: [etiqueta] BSF f,b
Ejemplo: BSF REG,2
Antes de la instrucción: REG=b’01001001′
Después de la instrucción: REG=b’01001011′

BTFSC: Checa un bit y salta si es 0
Si el bit “b” del registro “f” es 0, se salta una instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] BTFSC f,b

BTFSS: Checa un bit y salta si es 1
Si el bit “b” del registro “f” es 1, se salta una instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] BTFSS f,b

Instrucciones orientadas a constantes y de control

ANDLW: W AND literal
Realiza la operación lógica AND entre el registro W y la constante “k”. El resultado se almacena en el registro W.
Sintaxis: [label] ANDWL k
Flags afectados: Z
Ejemplo: ANDLW 0×5F
Antes de la instrucción: W=0xA3
Después de la instrucción: W=0×03

CALL: Llamada a subrutina
Llamada y salto a subrutina. La dirección de retorno se guarda en el stack. La constante “k” de 8 bits forma la dirección de salto y se carga en los bits del PC. Los bits del PC se cargan con los bits del registro “STATUS”. PC se pone a 0.
Sintaxis: [etiqueta] CALL k
Ejemplo: INICIO CALL DESTINO
Antes de la instrucción: PC=INICIO
Después de la instrucción: PC=DESTINO

CLRWDT: Borra el watchdog timer
Esta instrucción borra tanto el “watchdog” como el prescaler. Los bits TO y PD del registro de estado se ponen a “1″.
Sintaxis: [label] CLRWDT
Flags afectados: TO, PD

GOTO: Salto incondicional
Se trata de un salto incondicional. Los 9 bits de la constante “k” que forman la instrucción, se cargan en los bits del PC y forman la dirección de salto. Los bits del PC se cargan con los bits del registro de estado.
Sintaxis: [etiqueta] GOTO k
Ejemplo: INICIO GOTO DESTINO
Antes de la instrucción: PC=0
Después de la instrucción: PC=DESTINO

IORLW: W OR literal
Se realiza la función lógica OR entre el registro W y la contante “k”. El resultado se almacena en el registro W.
Sintaxis: [etiqueta] IORLW k
Flags afectados: Z
Ejemplo: IORLW Ox35
Antes de la instrucción: W=0×9A
Después de la instrucción: W=0xBF

MOVLW: Carga un literal en W
El registro W se carga con el valor de 8 bits expresado mediante la literal “k”.
Sintaxis: [etiqueta] MOVLW k
Ejemplo: MOVLW 0×5A
Después de la instrucción: W=0×5A

RETURN: Regresa de una subrutina
El programa regresa de la subrutina y ejecuta la instruccion que sigue a CALL
Sintaxis: [etiqueta] RETURN

RETLW: Regresa de una subrutina y carga el valor K en W
El programa regresa de la subrutina y carga el valor de 8 bits del registro k en el registro W
Sintaxis: [etiqueta] RETLW,k
Ejemplo: RETLW,0×45
Antes de la instruccion: W=xx
Despues de la instruccion: W=0×45

RETFIE: Regresa de la rutina de servicio
Sintaxis: [etiqueta] RETFIE

SLEEP: Entra en estado de reposo
Al salir, activa el bit de estado TO y borra el PD. El WDT y el prescaler se borran.Al entrar en el modo SLEEP, se detiene el oscilador.
Sintaxis: [etiqueta] SLEEP
Flags afectados: TO, PD, GPWUF

XORLW: W XOR literal
Realiza la función lógica OR exclusiva entre el contenido del registro W y la constante “k” de 8 bits. El resultado se almacena en el registro W.
Sintaxis: [etiqueta] XORLW k
Flags afectados: Z
Ejemplo: XORLW 0xAF
Antes de la instrucción: W = 0xB5
Después de la instrucción: W = 0×1A

SUBLW: Resta L – W
A una constante “k” de 8 bits se le resta el registro W. El resultado es guardado en el mismo registro W.
Sintaxis: [etiqueta] SUBLW k
Flags afectados: C,DC,Z

Y estas son las 35 instrucciones que podemos utilizar para programar los microcontroladores PIC. La razon para que solo se utilicen 35 instrucciones en la programacion es que los PIC son microcontroladores RISC, y estas instrucciones estan bien optimizadas para tener una mayor velocidad de trabajo, una arquitectura mas simple y un codigo mas compacto.