| |
Instrucciones orientadas a los bytes
Mnemónico |
Parámetros |
Descripción |
Ciclos |
Banderas |
ADDWF |
f, d |
Add W and f |
1 |
C, DC, Z |
ANDWF |
f, d |
AND W with f |
1 |
Z |
CLRF |
f |
Clear f |
1 |
Z |
CLRW |
- |
Clear W |
1 |
Z |
COMF |
f, d |
Complement f |
1 |
Z |
DECF |
f, d |
Decrement f |
1 |
Z |
DECFSZ |
f, d |
Decrement f, Skip if 0 |
1(2) |
None |
INCF |
f, d |
Increment f |
1 |
Z |
INCFSZ |
f, d |
Increment f, Skip if 0 |
1(2) |
None |
IORWF |
f, d |
Inclusive OR W with f |
1 |
Z |
MOVF |
f, d |
Move f |
1 |
Z |
MOVWF |
f |
Move W to f |
1 |
None |
NOP |
- |
No Operation |
1 |
None |
RLF |
f, d |
Rotate left f through carry |
1 |
C |
RRF |
f, d |
Rotate right f through carry |
1 |
C |
SUBWF |
f, d |
Subtract W from f |
1 |
C, DC, Z |
SWAPF |
f, d |
Swap nibbles in f |
1 |
None |
XORWF |
f, d |
Exclusive OR W with f |
1 |
Z |
Instrucciones orientadas a los bits
Mnemónico |
Parámetros |
Descripción |
Ciclos |
Banderas |
BCF |
f, b |
Bit Clear f |
1 |
None |
BSF |
f, b |
Bit Set f |
1 |
None |
BTFSC |
f, b |
Bit Test f, Skip if Clear |
1 (2) |
None |
BTFSS |
f, b |
Bit Test f, Skip if Set |
1 (2) |
None |
Operaciones con literales y de control
Mnemónico |
Parámetros |
Descripción |
NroCic. |
Banderas |
ADDLW |
k |
Add literal and W |
1 |
C, DC, Z |
ANDLW |
k |
AND literal with W |
1 |
Z |
CALL |
k |
Call subroutine |
2 |
|
CLRWDT |
- |
Clear Watchdog Timer |
1 |
TO,PD |
GOTO |
k |
Go to address |
2 |
None |
IORLW |
k |
Inclusive OR literal with W |
1 |
Z |
MOVLW |
k |
Move literal to W |
1 |
None |
RETFIE |
- |
Return from interrupt |
2 |
None |
RETLW |
k |
Return with literal in W |
2 |
None |
RETURN |
- |
Return from Subroutine |
2 |
None |
SLEEP |
- |
Go into standby mode |
1 |
TO,PD |
SUBLW |
k |
Subtract W from literal |
1 |
C, DC, Z |
XORLW |
k |
Exclusive OR literal with W |
1 |
Z |
LAS INTRUCCIONES DEL PIC 16F84
Introducción
Ya llegamos a la parte más interesante e importante del manejo de un microcontrolador: las instrucciones. Nuestro microcontrolador, como ya sabemos, pertenece a la gama media y es de tipo RISC; esto quiere decir que tiene un juego de instrucciones reducido, en concreto de 35. Estas 35 instrucciones o nemónicos (del inglés mnemonics(os recuerda a la película ;) ?) y a su vez proveniente del juego de palabras: Nem On Icks) serán la base de funcionamiento del PIC. Al igual que los bits de los registros, será imposible aprendernos todas y a la vez su funcionamiento, pero a la hora de codificar nuestros programas deberemos tenerlas en cuenta. Así, cuando tengamos dudas sobre su uso, esta guía será la chuleta ideal para recordarlo ;p.
Las instrucciones fundamentalmente se dividen en tres tipos. Esta división viene dada por el tipo de datos con los que trabajan:
-
Instrucciones orientadas a los bytes (byte-oriented operations)
-
Instrucciones orientadas a los bits (bit-oriented operations)
-
Operaciones con literales y de control (literal and control operations)
Aparte de estas instrucciones, hay otro tipo de instrucciones usadas para simplificar la tarea de programar, y q generalmente están formadas por dos instrucciones básicas. Estas no las trataremos a fondo, pero las veremos en un resumen después de comprender el funcionamiento de las 35 instrucciones básicas.
En los tres apartados siguientes veremos todos los datos que se pueden dar acerca de una función. Algunos de ellos son irrelevantes y no son nuestro objetivo. En cambio otros, como la acción, la sintaxis, el funcionamiento, la operación, el comportamiento del registro STATUS y los ejemplos, son imprescindibles para comprender su funcionamiento.
INSTRUCCIONES ORIENTADAS AL MANEJO DE BYTES (REGISTROS)
ADDWF
Acción |
Suma el contenido del acumulador y el registro dado, y el resultado lo guarda en d |
Sintaxis |
ADDWF f,d |
Funcionamiento |
Add W to file register (Añade W al registro) |
Hexadecimal |
07 ff |
Bits (OPCODE) |
00 0111 dfff ffff |
Operación |
d = W + f (d puede ser W ó f). |
Descripción |
Esta instrucción suma el contenido de un registro específico al contenido de W donde f puede ser un registro cualquiera con un determinado valor. |
Comentarios |
Aunque ya conocemos el funcionamiento del bit d, lo repetiré de nuevo para el resto de instrucciones:
-
Si vale 1, el resultado se guarda en el registro f
-
Si vale 0, el resultado se guarda en el acumulador W |
Registro STATUS |
Modifica los bits Z, DC y C.
- Z vale 1 si el resultado de la operación es 0.
- DC vale 1 si el resultado de la operación es un número superior a 15.
- C vale 1 si el resultado de la operación es positivo o el bit 7 del registro que contiene el resultado vale 0. En caso contrario C vale 0 (resultado negativo).
|
Ejemplo |
Tomamos como valores iniciales W = 5 y DATO = 10, donde dato es un registro cualquiera.
ADDWF DATO ; DATO = 15 y W = 5.
ADDWF DATO, 1 ; DATO = 15 y W = 5.
ADDWF DATO, 0 ; W = 15 y DATO = 10.
ADDWF DATO, W ; W = 15 y DATO = 10. |
Ciclos de máquina |
1 |
ANDWF
Acción |
Realiza la operación AND entre un registro y W |
Sintaxis |
ANDWF f,d |
Funcionamiento |
AND W with f |
Hexadecimal |
05 ff |
Bits (OPCODE) |
00 0101 dfff ffff |
Operación |
d = W AND f (d puede ser W o f). |
Descripción |
Esta instrucción realiza la operación lógica AND entre el acumulador y el registro f. el resultado se guarda dependiendo del valor de d. Si este se omite, el valor por defecto es 1 y se guarda en f |
Comentarios |
La operación AND es una de las operaciones básicas del álgebra de Boole. Esta viene descrita en el apartado de electrónica digital. Para comprender de nuevo cual es su comportamiento, recojo en la siguiente tabla los valores de la tabla de verdad de esta operación.
ENTRADA |
SALIDA |
f |
W |
S |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
1 |
La operación lógica es:
S = f · W
Esta instrucción realiza esta operación para cada uno de los 8 bits de los dos registros, dos a dos, guardando el resultado en el registro correspondiente. |
Registro STATUS |
Modifica el bit Z.
- Z vale 1 si el resultado de la operación es 0.
|
Ejemplo 1 |
Supongamos que W= 00001111 y f = 11110000 antes de ejecutar la instrucción ANDWF f,d
ENTRADA |
RESULTADO |
|
W |
f |
W · f |
Bit 7 |
0 |
1 |
0 |
Bit 6 |
0 |
1 |
0 |
Bit 5 |
0 |
1 |
0 |
Bit 4 |
0 |
1 |
0 |
Bit 3 |
1 |
0 |
0 |
Bit 2 |
1 |
0 |
0 |
Bit 1 |
1 |
0 |
0 |
Bit 0 |
1 |
0 |
0 |
|
Ejemplo 2 |
Ahora en nuestro segundo ejemplo tenemos que W = 01110011 y f = 00101001 antes de ejecutar la instrucción ANDWF f,d tenemos:
ENTRADA |
RESULTADO |
|
W |
f |
W · f |
Bit 7 |
0 |
0 |
0 |
Bit 6 |
1 |
0 |
0 |
Bit 5 |
1 |
1 |
1 |
Bit 4 |
1 |
0 |
0 |
Bit 3 |
0 |
1 |
0 |
Bit 2 |
0 |
0 |
0 |
Bit 1 |
1 |
0 |
0 |
Bit 0 |
1 |
1 |
1 |
|
Ciclos de máquina |
1 |
INSTRUCCIONES ORIENTADAS AL MANEJO DE BYTES (REGISTROS)
CLRF
Acción |
Borra un registro |
Sintaxis |
CLRF f |
Funcionamiento |
Clear file register |
Hexadecimal |
01 8f |
Bits (OPCODE) |
00 0001 1fff ffff |
Operación |
F = 0 |
Descripción |
Esta instrucción borra un registro específico, poniendo sus bits a cero |
Comentarios |
Ninguno |
Registro STATUS |
Modifica el bit Z y lo pone a 1 (ya que el resultado de la operación es 0). |
Ejemplo |
Tenemos un registro que se llama dato y que vale 3F. Ponemos:
CLRF dato
Ahora dato vale 00 |
Ciclos de máquina |
1 |
CLRW
Acción |
Borra el acumulador |
Sintaxis |
CLRW |
Funcionamiento |
Clear W |
Hexadecimal |
01 8f |
Bits (OPCODE) |
00 0001 0xxx xxxx |
Operación |
W = 0 |
Descripción |
Esta instrucción borra el registro W solamente |
Comentarios |
Donde pone xxx
en la instrucción en hexadecimal, significa que noo importa qué valor puede contener |
Registro STATUS |
Modifica el bit Z y lo pone a 1 (ya que el resultado de la operación es 0). |
Ejemplo |
Tenemos el acumulador cargado con el valor 3F. Ponemos:
CLRF dato
Ahora W vale 00 |
Ciclos de máquina |
1 |
COMF
Acción |
Complementa el registro F |
Sintaxis |
COMF f,d |
Funcionamiento |
Complement f |
Hexadecimal |
09 ff |
Bits (OPCODE) |
00 1001 dfff ffff |
Operación |
d = NOT f (d puede ser W ó f). |
Descripción |
Esta instrucción complementa un registro, es decir, los ceros los convierte en unos, y los unos en ceros. |
Comentarios |
ninguno |
Registro STATUS |
Modifica el bit Z.
- Z vale 1 si el resultado de la operación es 0.
|
Ejemplo |
Supongamos que tenemos un registro fdenominado regist = 00111011; cuando es aplicada la instrucción tenemos que los 0 cambian a valores 1 y los valores 1 cambian a 0 obteniéndose un registro invertido. El resultado será regist = 11000100. |
Ciclos de máquina |
1 |
DECF
Acción |
Decrementa el registro f |
Sintaxis |
DECF f,d |
Funcionamiento |
Decrement f |
Hexadecimal |
03 ff |
Bits (OPCODE) |
00 0011 dfff ffff |
Operación |
d = f 1 (d puede ser W ó f). |
Descripción |
Esta instrucción decrementa en una sola unidad el registro "f". |
Comentarios |
ninguno |
Registro STATUS |
Modifica el bit Z.
- Z vale 1 si el resultado de la operación es 0.
|
Ejemplo |
Nuestro registro se llama regist = 5; cuando se aplica la instrucción DECF f,0 el resultado será W=4.
Por el contrario, si aplicamos la instrucción DECF f,1 el resultado será regist = 4. |
Ciclos de máquina |
1 |
DECFSZ
Acción |
Decrementa el registro f, y si el resultado es cero, se salta una instrucción. |
Sintaxis |
DECFSZ f,d |
Funcionamiento |
Decrement f, skip if 0 |
Hexadecimal |
0B ff |
Bits (OPCODE) |
00 1011 dfff ffff |
Operación |
d = f 1, si d = 0 SALTA (d puede ser W ó f). |
Descripción |
Esta instrucción decrementa el contenido del registro direccionado por el parámetro f, y si el resultado es 0 salta la instrucción siguiente. Si no, sigue con su curso habitual |
Comentarios |
Aquí nos enfrentamos ante la primera instrucción que plantea una condición, y que modifica el curso del PC. |
Registro STATUS |
No modifica ningún bit de estado |
Ejemplo |
DECFSZ VALOR, W
INSTRUCCION 1
INSTRUCCIÓN 2
Si el contenido del registro VALOR al decrementarlo es igual a 0, se guarda el resultado en el acumulador y sigue con la INSTRUCCION2, saltándose la INSTRUCCION1.
Si el resultado que guardamos en W no es 0, sigue con la INSTRUCCION1 y después con la INSTRUCCION2 (no se salta la inmediata siguiente). |
Ciclos de máquina |
1 (2) Si tiene que saltar ocupa dos ciclos |
INCF
Acción |
Suma una unidad al registro f |
Sintaxis |
INCF f,d |
Funcionamiento |
Increment f |
Hexadecimal |
0A ff |
Bits (OPCODE) |
00 1010 dfff ffff |
Operación |
d = f + 1 (d puede ser W ó f). |
Descripción |
Esta instrucción incrementa en una sola unidad el registro "f". |
Comentarios |
Ninguno |
Registro STATUS |
Modifica el bit Z.
- Z vale 1 si el resultado de la operación es 0.
|
Ejemplo |
Si tenemos un registro llamado DIA = 7.
Aplicando la instrucción
INCF DIA, 0, tendremos W = 8 y DIA = 7.
Si aplicamos esta otra
INCF DIA, 1, tendremos DIA = 8. |
Ciclos de máquina |
1 |
INCFSZ
Acción |
Incrementa en 1 a f, y si f= 0 salta la siguiente instrucción |
Sintaxis |
INCFSZ f,d |
Funcionamiento |
Increment f, Skip if 0 |
Hexadecimal |
0F ff |
Bits (OPCODE) |
00 1111 dfff ffff |
Operación |
d = f + 1, si d = 0 SALTA (d puede ser W ó f). |
Descripción |
Esta instrucción incrementa en una sola unidad el registro "f", en la cual si el resultado d es igual a cero, entonces salta la instrucción siguiente. |
Comentarios |
Ninguno |
Registro STATUS |
No modifica ningún bit de estado. |
Ejemplo |
Ejecutamos las siguiente sinstrucciones:
INCFSZ VALOR, W ; el resultado se almacenará en W
INSTRUCCION 1 ; salta aquí si W≠0
INSTRUCCIÓN 2 ; salta aquí si W=0
Si el contenido del registro VALOR es igual a 0 al incrementarlo en una unidad, se guarda el resultado en el acumulador y sigue con la INSTRUCCION2, saltándose la INSTRUCCION1.
Si el resultado que guardamos en W no es 0, sigue con la INSTRUCCION1 y después con la INSTRUCCION2 (no se salta la inmediata siguiente). |
Ciclos de máquina |
1 (2) Si tiene que saltar ocupa dos ciclos |
IORWF
Acción |
Operación lógica OR entre el acumulador y un registro |
Sintaxis |
IORWF f,d |
Funcionamiento |
Inclusive Or W with F |
Hexadecimal |
04 ff |
Bits (OPCODE) |
00 0100 dfff ffff |
Operación |
d = W OR f (d puede ser W ó f). |
Descripción |
Esta instrucción realiza una operación lógica OR inclusivo entre el acumulador W y el registro direccionado por el parámetro f. El parámetro d determina donde se almacenará el resultado de la operación. Si no se pone nada, el valor por defecto es 1 y se guarda en f. |
Comentarios |
La operación OR inclusivo suele llamarse OR a secas, pero se pone así para diferenciarla de la Suma Exclusiva que veremos más adelante. La tabla de verdad de la suma lógica es la que sigue:
ENTRADA |
SALIDA |
f |
W |
S |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
La operación lógica que describe esta instrucción es esta:
F + W = S
Se puede ver que basta con que uno de los dos registros tenga un uno para que la salida sea un uno también. |
Registro STATUS |
Modifica el bit Z.
- Z vale 1 si el resultado de la operación es 0.
|
Ejemplo 1 |
Supongamos que W= 00001111 y f = 11110000 antes de ejecutar la instrucción IORWF f,d, y después obtenemos:
ENTRADA |
RESULTADO |
|
W |
f |
W + f |
Bit 7 |
0 |
1 |
1 |
Bit 6 |
0 |
1 |
1 |
Bit 5 |
0 |
1 |
1 |
Bit 4 |
0 |
1 |
1 |
Bit 3 |
1 |
0 |
1 |
Bit 2 |
1 |
0 |
1 |
Bit 1 |
1 |
0 |
1 |
Bit 0 |
1 |
0 |
1 |
|
Ejemplo 2 |
En este segundo ejemplo tenemos que W = 01110011 y f = 00101001, antes de ejecutar la instrucción IORWF f,d, y después obtenemos que:
ENTRADA |
RESULTADO |
|
W |
f |
W + f |
Bit 7 |
0 |
0 |
0 |
Bit 6 |
1 |
0 |
1 |
Bit 5 |
1 |
1 |
1 |
Bit 4 |
1 |
0 |
1 |
Bit 3 |
0 |
1 |
1 |
Bit 2 |
0 |
0 |
0 |
Bit 1 |
1 |
0 |
1 |
Bit 0 |
1 |
1 |
1 |
Al igual que el caso anterior, el microcontrolador compara bit a bit los dos registros, dos a dos, obteniendo el resultado expresado en W + f |
Ciclos de máquina |
1 |
MOVF
Acción |
Mueve el contenido de un registro al acumulador o al propio registro |
Sintaxis |
MOVF f,d |
Funcionamiento |
Move f |
Hexadecimal |
08 ff |
Bits (OPCODE) |
00 1000 dfff ffff |
Operación |
d = f (d puede ser W ó f). |
Descripción |
Esta instrucción mueve el contenido del registro f en el mismo registro f o en W. D determina el destino del resultado. Si no se pone nada, el valor por defecto es 1 y se guarda en f. |
Comentarios |
Se suele usar para mover datos al acumulador. El hecho de que se pueda mover sobre sí mismo no es otro que para mirar el resultado en el registro STATUS (no es ninguna tontería ;)) |
Registro STATUS |
Modifica el bit Z.
- Z vale 1 si el resultado de la operación es 0.
|
Ejemplo |
Tenemos el registro EDAD = 38
MOVF EDAD, 0 ; hace que W = 38.
MOVF EDAD, 1 ; hace que EDAD = 38.
MOVF EDAD, W ; hace que W = 38.
MOVF EDAD ; hace que EDAD = 38. |
Ciclos de máquina |
1 |
MOVWF
Acción |
Mueve el acumulador al registro f |
Sintaxis |
MOVWF f |
Funcionamiento |
Move W to f |
Hexadecimal |
00 ff |
Bits (OPCODE) |
00 0000 1fff ffff |
Operación |
f = W |
Descripción |
Esta instrucción copia el contenido del acumulador W en el registro direccionado por el parámetro f. |
Comentarios |
No existe el parámetro d (lógico, o no? En este caso no se puede copiar el acumulador sobre sí mismo :p ) |
Registro STATUS |
No modifica ningún bit de estado. |
Ejemplo |
Si queremos escribir el valor 10H en el registro TMR0, que está situado en la dirección 01h, tendremos que cargar primero el valor en el acumulador y después copiarlo al registro.
MOVWF 10H ; cargar el valor 10H en el acumulador.
MOVWF 01H ; copia el acumulador en la dirección 01H.
O escrito de otra manera:
MOVWF 10H ; cargar el valor 10H en el acumulador.
MOVWF TMR0 ; copia el acumulador en el registro TMR0. |
Ciclos de máquina |
1 |
NOP
Acción |
No opera |
Sintaxis |
NOP |
Funcionamiento |
No Operation |
Hexadecimal |
00 00 |
Bits (OPCODE) |
00 0000 0xx0 0000 |
Operación |
Ninguna |
Descripción |
Esta instrucción no reliza ninguna ejecución, pero sirve para gastar un ciclo de máquina, equivalente a 4 de reloj |
Comentarios |
Ninguno |
Registro STATUS |
No modifica ningún bit de estado. |
Ejemplo |
Si usamos un cristal de cuarzo de 4 Mhz. en el oscilador, podremos obtener un retardo igual a un microsegundo por cada instrucción NOP que insertemos en el código del programa:
RETARDO NOP
NOP
NOP
RETURN
Cada vez que llamemos a la subrutina RETARDO, obtendremos 3 microsegundos de demora. |
Ciclos de máquina |
1 |
RLF
Acción |
Rota a la izquierda el registro f |
Sintaxis |
RLF f,d |
Funcionamiento |
Rotate Left through Carry f |
Hexadecimal |
0D ff |
Bits (OPCODE) |
00 1101 dfff ffff |
Operación |
d = << 1 (d puede ser W ó f). |
Descripción |
Esta instrucción rota a la izquierda todos los bits del registro direccionado por el parámetro fpasando por el bit CARRY del registro STATUS (desde los bits menos significativos a los más significativos).
Es como si multiplicáramos por dos el contenido del registro.
Veamos el registro fde forma gráfica:
El bit D7 pasa al CARRY del registro STATUS, el contenido del CARRY pasa al D0, el D0 al D1, etc. |
Comentarios |
Ninguno |
Registro STATUS |
Modifica el bit C (CARRY). |
Ejemplo |
Tenemos el registro VALOR = 00000001 y aplicamos la instrucción
RLF VALOR
Entonces el resultado será VALOR = 00000010 y el bit C = 0.
Si tenemos el registro VALOR = 10000000 y aplicamos la instrucción
RLF VALOR
El resultado será VALOR = 00000000 y el bit C = 1. |
Ciclos de máquina |
1 |
RRF
Acción |
Rota a la derecha el registro f |
Sintaxis |
RRF f,d |
Funcionamiento |
Rotate Right through Carry f |
Hexadecimal |
0C ff |
Bits (OPCODE) |
00 1100 dfff ffff |
Operación |
d = f >> 1 (d puede ser W ó f). |
Descripción |
Esta instrucción rota a la derecha todos los bits del registro direccionado por el parámetro fpasando por el bit CARRY del registro STATUS (desde los bits más significativos a los menos significativos).
Es como si dividiéramos por dos el contenido del registro.
Veamos el registro fde forma gráfica:
El bit C del registro STATUS pasa al D7, el D0 pasa al bit C, el D1 al D0, etc.
El bit d determina el destino del resultado. Si no se pone nada, el valor por defecto es 1 y se guarda en f. |
Comentarios |
Ninguno |
Registro STATUS |
Modifica el bit C (CARRY). |
Ejemplo |
Si tenemos el registro VALOR = 00000001 y aplicamos la instrucción
RRF VALOR
Entonces el resultado será VALOR = 00000000 y el bit C = 1.
Si tenemos el registro VALOR = 10000000 y aplicamos la instrucción
RRF VALOR
El resultado será VALOR = 01000000 y el bit C = 0. |
Ciclos de máquina |
1 |
SUBWF
Acción |
Resta el contenido del registro W el registro f |
Sintaxis |
SUBWF f,d |
Funcionamiento |
Subtract W from f |
Hexadecimal |
02 ff |
Bits (OPCODE) |
00 0010 dfff ffff |
Operación |
d = f W (d puede ser W ó f). |
Descripción |
Esta instrucción resta el valor contenido en el acumulador W del valor contenido en el registro direccionado por el parámetro f. El parámetro ddetermina el destino. Si no se pone nada el valor por defecto será 1 y se almacenará en f. |
Comentarios |
Ninguno |
Registro STATUS |
Modifica los bits Z, DC y C.
- Z vale 1 si el resultado de la operación es 0.
- DC vale 1 si el resultado de la operación es un número superior a 15.
C vale 1 si el resultado de la operación es positivo o el bit 7 del registro que contiene el resultado vale 0. En caso contrario C vale 0 (resultado negativo). |
Ejemplo |
Según sean los valores de W y el registro DATO, si aplicamos
SUBWF DATO
obtendremos diferentes resultados en el bit CARRY.
Si DATO = 3 y W = 2; el resultado será DATO = 1 y C = 1.
Si DATO = 2 y W = 2; el resultado será DATO = 0 y C = 1.
Si DATO = 1 y W = 2; el resultado será DATO = FFH y C = 0.
Vemos que C = 1 porque el resultado es positivo y C = 0 cuando el resultado es negativo. |
Ciclos de máquina |
1 |
SWAPF
Acción |
Invierte los dos nibbles que forman un byte dentro de un registro |
Sintaxis |
SWAPF f,d |
Funcionamiento |
Swap nibbles in f |
Hexadecimal |
0E ff |
Bits (OPCODE) |
00 1110 dfff ffff |
Operación |
f = 0123 SWAP 4567 de f |
Descripción |
Esta instrucción intercambia el valor de los 4 bits más significativos (D7-D4) contenidos en el registro f, con los 4 bits menos significativos (D3-D0) del mismo. El parámetro d determina el destino. Si no se pone nada, el valor por defecto es 1 y se guarda en f. |
Comentarios |
Ninguno |
Registro STATUS |
No modifica ningún bit de estado. |
Ejemplo |
Tenemos VALOR = 00001111 y W = 00000000. Aplicamos la instrucción SWAPF
SWAPF VALOR ; VALOR = 11110000B y W = 00000000B.
SWAPF VALOR, W ; VALOR = 00001111B y W = 11110000B.
Con la primera instrucción modificamos el valor del registro DATO, y en la segunda instrucción modificamos el valor del acumulador sin que varíe el registro DATO |
Ciclos de máquina |
1 |
XORWF
Acción |
Operación lógica OR-Exclusiva |
Sintaxis |
XORWF f,d |
Funcionamiento |
Exclusive OR W with f |
Hexadecimal |
06 ff |
Bits (OPCODE) |
00 0110 dfff ffff |
Operación |
d = W OR f |
Descripción |
Esta instrucción efectúa la operación lógica XOR (OR exclusivo) entre el valor contenido en el acumulador W y el valor contenido en el registro direccionado por el parámetro f. El parámetro d determina el destino. Si no se pone nada el valor por defecto es 1 y se guarda en f |
Comentarios |
Al igual que las otras operaciones lógicas, la suma exclusiva está tratada en el capítulo de electrónica digital. No obstante expongo las tablas de verdad correspondientes a esta operación
ENTRADA |
SALIDA |
f |
W |
S |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
La salida únicamente se podrá a nivel alto cuando las dos entradas sean distintas. Esto es útil cuando tenemos una suma lógica en la que 1 + 1 es 10 y nos llevamos 1.
Esta operación algebraicamente se expresa así:
S = f + W
|
Registro STATUS |
Modifica el bit Z.
Z vale 1 si el resultado de la operación es 0. |
Ejemplo 1 |
Tenemos dos registros que se corresponden con los siguientes valores W= 00001111 y f = 11110000 antes de ejecutar la instrucción XORWF f,d. Una vez ejecutada obtenemos la siguiente tabla de verdad sobre los dos registros:
ENTRADA |
RESULTADO |
|
W |
f |
W + f |
Bit 7 |
0 |
1 |
1 |
Bit 6 |
0 |
1 |
1 |
Bit 5 |
0 |
1 |
1 |
Bit 4 |
0 |
1 |
1 |
Bit 3 |
1 |
0 |
1 |
Bit 2 |
1 |
0 |
1 |
Bit 1 |
1 |
0 |
1 |
Bit 0 |
1 |
0 |
1 |
El PIC compara dos a dos los bits de los registros |
Ejemplo 2 |
Ahora W = 01110011 y f = 00101001 antes de ejecutar la instrucción XORWF f,d y después obtenemos:
ENTRADA |
RESULTADO |
|
W |
f |
W + f |
Bit 7 |
0 |
0 |
0 |
Bit 6 |
1 |
0 |
1 |
Bit 5 |
1 |
1 |
1 |
Bit 4 |
1 |
0 |
1 |
Bit 3 |
0 |
1 |
1 |
Bit 2 |
0 |
0 |
0 |
Bit 1 |
1 |
0 |
1 |
Bit 0 |
1 |
1 |
0 |
|
Ciclos de máquina |
1 |
INSTRUCCIONES ORIENTADAS AL MANEJO DE BITS
BCF
Acción |
Pone a cero el bit b del registro f |
Sintaxis |
BCF f,b |
Funcionamiento |
Bit Clear f |
Hexadecimal |
1b ff |
Bits |
01 00bb bfff ffff |
Operación |
F(b) = 0 |
Descripción |
Esta instrucción pone a cero un bit que hayamos elegido de un registro determinado. |
Comentarios |
No debemos olvidar que en la numeración de los bits también se tiene en cuenta el 0. Si tratamos con un registro especial, podemos poner el nombre del bit correspondiente. |
Registro STATUS |
No modifica ningún bit de estado. |
Ejemplo |
BCF PORTA, RA4 ; pone a 0 el bit RA4 del registro PORTA
BCF PORTA, 4 ; igual, si no conocemos en nombre del bit
Si en el PORTA tenemos como valor inicial 11111111, después de aplicar el ejemplo anterior, PORTA = 11101111. |
Ciclos de máquina |
1 |
BSF
Acción |
Pone a uno el bit b del registro f |
Sintaxis |
BSF f,b |
Funcionamiento |
Bit Set f |
Hexadecimal |
1b ff |
Bits (OPCODE) |
01 01bb bfff ffff |
Operación |
F(b) = 1 |
Descripción |
Esta instrucción pone a uno un bit que hayamos elegido de un registro determinado. |
Comentarios |
Ninguno |
Registro STATUS |
No modifica ningún bit de estado. |
Ejemplo |
BSF PORTA, RA0 ; pone a 1 el bit RA0 del registro PORTA
BSF PORTA, 0 ; igual, si no conocemos en nombre del bit
Si en el PORTA tenemos como valor inicial 00000000, después de aplicar el ejemplo anterior, PORTA = 00000001. |
Ciclos de máquina |
1 |
BTFSC
Acción |
Comprueba un bit b del registro f, y salta la instrucción siguiente si este es cero |
Sintaxis |
BTFSC f,b |
Funcionamiento |
Bit Test, Skip if Clear |
Hexadecimal |
1b ff |
Bits (OPCODE) |
01 10bb bfff ffff |
Operación |
F(b) = 0? SI, salta una instrucción |
Descripción |
Esta instrucción comprueba el valor del bit b en el registro f, y si b = 0 entonces se salta la siguiente instrucción. Si b = 1 no salta y sigue con su ejecución normal. |
Comentarios |
Ninguno |
Registro STATUS |
No modifica ningún bit de estado |
Ejemplo |
BTFSC PORTA, 2
INSTRUCCIÓN 1
INSTRUCCIÓN 2
Si en PORTA tenemos como valor inicial 11111011, el programa continúa con la instrucción 2, saltándose la instrucción 1
Si en PORTA tenemos el valor 00000100, el programa sigue con la instrucción 1 y después la instrucción 2 |
Ciclos de máquina |
1 (2) Si tiene que saltar ocupa dos ciclos |
BTFSS
Acción |
Comprueba un bit b del registro f, y salta la instrucción siguiente si este es uno |
Sintaxis |
BTFSC f,b |
Funcionamiento |
Bit Test, Skip if Set |
Hexadecimal |
1b ff |
Bits (OPCODE) |
01 11bb bfff ffff |
Operación |
F(b) = 1? SI, salta una instrucción |
Descripción |
Esta instrucción comprueba el valor del bit b en el registro f, y si b = 1 entonces se salta la siguiente instrucción. Si b = 0 no salta y sigue con su ejecución normal. |
Comentarios |
Ninguno |
Registro STATUS |
No modifica ningún bit de estado |
Ejemplo |
BTFSS PORTB, 7
INSTRUCCIÓN 1
INSTRUCCIÓN 2
Si en PORTB tenemos como valor inicial 10000000, el programa continúa con la instrucción 2, saltándose la instrucción 1. Si tenemos el valor 01111111, el programa sigue con la instrucción 1 y después la instrucción 2. |
Ciclos de máquina |
1 (2) Si tiene que saltar ocupa dos ciclos |
OPERACIONES CON LITERALES Y DE CONTROL
ADDLW
Acción |
Suma a W un literal |
|
