|
ADDWF |
Suma W y f |
|
Sintaxis: |
[label] ADDWF f,d |
Operandos: |
d=0 ó d=1; 0 <= f
<= 31 |
Operación: |
(W) + (f) --> (dest) |
Flags afectados: |
C, DC, Z |
Descripción: |
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".
|
Ejemplo: |
ADDWF
REG,0
Antes
de la instrucción:
Después de la instrucción: |
W=
0x17
REF=
0xC2
W=
0xD9
REG=
0xC2 |
|
ANDWF |
W AND f |
|
Sintaxis: |
[label]
ANDWF f,d |
Operandos: |
d=0 ó d=1; 0 <= f
<= 31 |
Operación: |
(W) AND (f) --> (dest) |
Flags afectados: |
Z |
Descripción: |
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".
|
Ejemplo: |
ANDWF
REG,1
Antes
de la instrucción:
Después de la instrucción: |
W=0x17
REG=
0xC2
W=0x17
REG=
0x02 |
|
ANDLW |
W AND literal |
|
Sintaxis: |
[label]
ANDWL k |
Operandos: |
0 <= k <= 255 |
Operación: |
(W) AND (k) --> (W) |
Flags afectados: |
Z |
Descripción: |
Realiza la operación lógica AND entre el registro W y la constante "k".
El resultado se almacena en el registro W.
|
Ejemplo: |
ANDLW
0x5F
Antes
de la instrucción:
Después de la instrucción: |
W=
0xA3
W=
0x03 |
|
BCF |
Borra un bit |
|
Sintaxis: |
[label]
BCF f,b |
Operandos: |
0 <= f <= 31; 0 <=
b <= 7; |
Operación: |
0 --> (f < b >) |
Flags afectados: |
Ninguno
|
Descripción: |
Borra el bit "b"
del registro "f". |
Ejemplo: |
BCF
REG,7
Antes
de la instrucción:
Después de la instrucción: |
REG =
0x0A
REG =
0x47 |
|
BSF |
Activa un bit |
|
Sintaxis: |
[label]
BSF f,b |
Operandos: |
0 <= f <= 31; 0 <=
b <= 7; |
Operación: |
1 --> (f < b >) |
Flags afectados: |
Ninguno
|
Descripción: |
Activa el bit "b"
del registro "f". |
Ejemplo: |
BSF
REG,0x0A
Antes
de la instrucción:
Después de la instrucción: |
REG =
0x0A
REG =
0x8A |
|
BTFSC |
Test de bit y salto |
|
Sintaxis: |
[label]
BTFSC f,b |
Operandos: |
0 <= f <= 31; 0 <=
b <= 7; |
Operación: |
Salto si (f < b >)
= 0 |
Flags afectados: |
Ninguno
|
Descripción: |
Si el
bit "b" del registro "f" es 0, se salta una instrucción y se continúa
con la ejecución.
|
Ejemplo: |
COM
BTFSC REG,1
FALSE
GOTO PROCESA_X
TRUE
°
Antes
de la instrucción:
Después de la instrucción: |
PC=
Dirección (COM_)
SI REG
<1> = 0
PC= Dirección (TRUE)
SI REG
<1> = 1
PC= Dirección (FALSE) |
|
BTFSS |
Test de bit y salto |
|
Sintaxis: |
[label]
BTFSS f,b |
Operandos: |
0 <= f <= 31; 0 <=
b <= 7; |
Operación: |
Salto si (f < b >)
= 1 |
Flags afectados: |
Ninguno |
Descripción: |
Si el
bit "b" del registro "f" es 1, se salta una instrucción y se continúa
con la ejecución.
|
Ejemplo: |
COM
BTFSS REG,6
FALSE
GOTO PROCESA_X
TRUE
°
Antes
de la instrucción:
Después de la instrucción:
|
PC=
Dirección (COM_)
SI REG
<6> = 0
PC= Dirección (FALSE)
SI REG
<6> = 1
PC= Dirección (TRUE) |
|
CALL |
Salto a subrutina |
|
Sintaxis: |
[label]
CALL k |
Operandos: |
0 <= k <= 255 |
Operación: |
(PC) + 1 --> stack;
k --> PC |
Flags afectados: |
Ninguno |
Descripción: |
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 <7:0>
del PC.
Los
bits <10:9> del PC se cargan con los bits <6:5> del registro "STATUS".
PC <8> se pone a 0.
|
Ejemplo: |
ORG
CALL DESTINO
Antes
de la instrucción:
Después de la instrucción: |
PC =
ORG
PC =
DESTINO |
|
CLRF |
Borra un registro |
|
Sintaxis: |
[label]
CLRF f |
Operandos: |
0 <= f <= 32 |
Operación: |
00f --> (f); 1 -->
Z |
Flags afectados: |
Z |
Descripción: |
Se
borra el contenido del registro "f" y el flag Z de estado se activa.
|
Ejemplo: |
CLRF
REG
Antes
de la instrucción:
Después de la instrucción: |
REG =
0x5A
REG =
0x00
Z = 1 |
|
CLRW |
Borra el registro W |
|
Sintaxis: |
[label]
CLRW |
Operandos: |
Ninguno |
Operación: |
00h --> W; 1 --> Z |
Flags afectados: |
Z |
Descripción: |
El
registro de trabajo "W" se carga con 00h. El flag de Z se activa.
|
Ejemplo: |
CLRW
Antes
de la instrucción:
Después de la instrucción: |
W =
0x5A
W =
0x00
Z = 1 |
|
CLRWDT |
Borra el "watchdog" |
|
Sintaxis: |
[label]
CLRWDT |
Operandos: |
Ninguno |
Operación: |
00h --> WDT; 1 -->
TO; 1 -->
PD; |
Flags afectados: |
TO,
PD |
Descripción: |
Esta
instrucción borra tanto el "watchdog" como el prescaler. Los bits
TO y
PD del registro de estado
se ponen a "1".
|
Ejemplo: |
CLRWDT
Después de la instrucción: |
Contador WDT = 0
Prescaler WDT = 0
Bit de
estado TO = 1
Bit de
estado PD = 1 |
|
COMF |
Complementa f |
|
Sintaxis: |
label COMF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(f) --> (dest) |
Flags afectados: |
Z |
Descripción: |
El
contenido del registro "f" se complementa. Si "d" es 0 el resultado "R"
se almacena en el registro W. Si "d" es 1, el resultado "R" se almacena
en el registro "f".
|
Ejemplo: |
|
|
DECF |
Decremento de f |
|
Sintaxis: |
[label]
DECF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(f) - 1 --> (dest) |
Flags afectados: |
Z |
Descripción: |
Se
decrementa en una unidad el contenido del registro "f". Si "d" es 0, el
resultado se almacena en W. Si "d" es 1, el resultado se almacena en
"f".
|
Ejemplo: |
DEC
CONT, 1
Antes
de la instrucción:
Después de la instrucción: |
CONT =
0x01
Z = 0
CONT =
0x00
Z = 1 |
|
DECFSZ |
Decremento y salto |
|
Sintaxis: |
[label]
DECFSZ f,d |
Operandos: |
0 <= f <= 32; d = 0
ó d = 1 |
Operación: |
(f) - 1 --> d;
Salto si R = 0 |
Flags afectados: |
Ninguno |
Descripción: |
El
contenido del registro "f" se decrementa. Si "d" es 0, el resultado "R"
se coloca en el registro W. Si "d" es 1, el resultado "R" se coloca en
el registro "f". Si R = 0, se salta la siguiente instrucción y se
continúa con la ejecución.
|
Ejemplo: |
COM_
DECFSZ REG,O
GOTO_NO_ES_0
Antes
de la instrucción:
Después de la instrucción: |
PC =
Dirección (COM_)
REG =
REG - 1
SI REG
= 0
PC = Dirección CONTINUA
SI REG
!= 0
PC = Dirección (COM_ + 1) |
|
GOTO |
Salto incondicional |
|
Sintaxis: |
[label]
GOTO k |
Operandos: |
0 <= k <= 511 |
Operación: |
k --> PC --> <8:0> |
Flags afectados: |
Ninguno |
Descripción: |
Se
trata de un salto incondicional. Los 9 bits de la constante "k" que
forman la instrucción, se cargan en los bits <8:0> del PC y forman la
dirección de salto. Los bits <10:9> del PC se cargan con los bits <6:5>
del registro de estado.
|
Ejemplo: |
ORG
GOTO DESTINO
Antes
de la instrucción:
Después de la instrucción: |
PC = 0
PC =
DESTINO |
|
INCF |
Incremento de f |
|
Sintaxis: |
[label]
INCF f,d |
Operandos: |
0 <= k <= 31; d = 0
ó d = 1 |
Operación: |
(f) + 1 --> (dest) |
Flags afectados: |
Z |
Descripción: |
Incrementa en una unidad el contenido del registro "f". Si "d" es 0, el
resultado se almacena en W. Si "d" es 1, el resultado se almacena en
"f".
|
Ejemplo: |
INCF
CONT,1
Antes
de la instrucción:
Después de la instrucción: |
CONT =
0xFF
Z = 0
CONT =
0x00
Z = 1 |
|
INCFSZ |
Incremento de f, si es 0 salta |
|
Sintaxis: |
[label]
INCFSZ f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(f) + 1 --> (dest);
Salto si R = 0 |
Flags afectados: |
Ninguno |
Descripción: |
Incrementa en una unidad el contenido del registro "f". Si "d" es 0, el
resultado se almacena en W. Si "d" es 1, el resultado se almacena en
"f". Si R=0, se salta la siguiente instrucción y se continúa con la
ejecución.
|
Ejemplo: |
COM_
INCFSZ REG,1
GOTO_NO_ES_0
CONTINUA
Antes
de la instrucción:
Después de la instrucción: |
PC =
Dirección (COM_)
CONT +
1
SI CNT
= 0
PC = Dirección CONTINUA
SI REG
!= 0
PC = Dirección (COM_ + 1) |
|
IORLW |
W OR literal |
|
Sintaxis: |
[label]
IORLW k |
Operandos: |
0 <= f <= 255 |
Operación: |
(W).OR.(k) --> (W) |
Flags afectados: |
Z |
Descripción: |
Se
realiza la función lógica OR entre el registro W y la contante "k". El
resultado se almacena en el registro W. |
Ejemplo: |
IORLW
Ox35
Antes
de la instrucción:
Después de la instrucción: |
W =
0x9A
W =
0xBF |
|
IORWF |
OR entre W y f |
|
Sintaxis: |
[label]
IORWF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(W).OR.(f) --> (dest) |
Flags afectados: |
Z |
Descripción: |
Realiza la operación lógica OR 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 almacen en el registro "f".
|
Ejemplo: |
IORWF
REG,0
Antes
de la instrucción:
Después de la instrucción: |
RESULTADO = 0x13
W =
0x91
RESULTADO = 0x13
W =
0x93
Z = 0 |
|
MOVF |
Mover a f |
|
Sintaxis: |
[label]
MOVF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(f) --> (dest) |
Flags afectados: |
Z |
Descripción: |
El
contenido del registro "f" se mueve al destino "d". Si "d" es 0, el
destino es el registro w. Si "d" es 1, el destino es el propio registro
"f". Esta posibilidad permite verificar dicho registro ya que el flag Z
queda afectado.
|
Ejemplo: |
MOVF
REG,0
Después de la instrucción: |
W =
REG |
|
MOVLW |
Carga un literal en W |
|
Sintaxis: |
label MOVLW k |
Operandos: |
0 <= f <= 255 |
Operación: |
(k) --> (W) |
Flags afectados: |
Ninguno |
Descripción: |
El
registro W se carga con el valor de 8 bits expresado mediante la literal
"k".
|
Ejemplo: |
MOVLW
0x5A
Después de la instrucción: |
W =
0x5A |
|
MOVWF |
Mover W a f |
|
Sintaxis: |
label MOVWF f |
Operandos: |
0 <= f <= 31 |
Operación: |
(W) --> (dest) |
Flags afectados: |
Ninguno |
Descripción: |
Mueve el contenido
del registro W al registro "f". |
Ejemplo: |
MOVWF
REG
Antes
de la instrucción:
Después de la instrucción: |
REG =
0xFF
W =
0x4F
REG =
0x4F
W =
0x4F |
|
NOP |
No operar |
|
Sintaxis: |
[label]
NOP |
Operandos: |
Ninguno |
Operación: |
No operar |
Flags afectados: |
Ninguno |
Descripción: |
No
realiza operación alguna. Consume un ciclo de instrucción.
|
Ejemplo: |
NOP |
|
OPTION |
Carga reg. OPTION |
|
Sintaxis: |
[label]
OPTION |
Operandos: |
Ninguno |
Operación: |
(W) --> OPTION |
Flags afectados: |
Ninguno |
Descripción: |
El
contenido del registro W se carga en el registro OPTION. Este es un
registro de sólo escritura donde se configura el funcionamiento del
prescaler y el TMR0.
|
Ejemplo: |
OPTION
Antes
de la instrucción:
Después de la instrucción: |
W =
0x07
OPTION
= 0x07 |
|
RETLW |
Retorno, carga W |
|
Sintaxis: |
[label]
RETWL k |
Operandos: |
0 <= f <= 255 |
Operación: |
(k) --> (W); TOS
--> PC |
Flags afectados: |
Ninguno |
Descripción: |
El
registro W se carga con los 8 bits de la constante k. El PC se carga con
el contenido de la cima stack (TOS): dirección de retorno. Esta
instrucción consume dos ciclos.
|
Ejemplo:
TABLA |
CALL
TABLA ;contiene el offset
;de la tabla. |
W = 07
W = Valor de K8 |
. ;Ahora W tiene el |
. ;valor de la tabla
ADDWF
PC ;W offset
RETLW
K1 ;comienza tabla
RETLW
K2
.
.
RETLW
Kn ;Fin de la tabla
Antes
de la instrucción:
Después de la instrucción: |
|
RLF |
Rota f a la izquierda |
|
Sintaxis: |
[label]
RLF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
Rotación a la
izquierda de f |
Flags afectados: |
C |
Descripción: |
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" es 0, el resultado se coloca en el registro W. Si
"d" es 1, el resultado queda en el registro "f".
|
Ejemplo: |
RLF
REG1,0
Antes
de la instrucción:
Después de la instrucción: |
REG1 =
11100110
C = 0
REG1 =
11100110
W =
11001100
C = 1 |
|
RRF |
Rota f a la derecha |
|
Sintaxis: |
[label]
RRF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
Rotación a la
derecha |
Flags afectados: |
C |
Descripción: |
El contenido del
registro "f" se rota a la derecha. El bit de menos peso de "f" pasa al
flag carry. El carry se coloca en el bit de más peso de "f". Si "d" es
0, el resultado se almacena en el registro W. Si "d" es 1, el resultado
se almacena en "f". |
Ejemplo: |
RRF
REG1
Antes
de la instrucción:
Después de la instrucción: |
REG1 =
11100110
C = 0
REG1 =
11100110
W =
01110011
C = 0 |
|
SLEEP |
Pasa a estado de reposo |
|
Sintaxis: |
[label]
SLEEP |
Operandos: |
Ninguno |
Operación: |
ooh --> WDT; 0 -->
WDT prescaler; 1 --> TO;
0 --> PD |
Flags afectados: |
TO,
PD, GPWUF |
Descripción: |
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.
|
Ejemplo: |
SLEEP |
|
|
SUBWF |
Resta f - W |
|
Sintaxis: |
[label]
SUBWF f,d |
Operandos: |
0 <= f <= 32; d = 0
ó d = 1 |
Operación: |
(f) - (W) --> (dest) |
Flags afectados: |
C, DC, Z |
Descripción: |
Resta,
por el método del complemento a 2, el contenido del registro "f" menos
el contenido del registro W. Si "d" es 0, el resultado se almacena en el
registro W. Si "d" es 1, el resultado se almacena en el registro "f". Si
el resultado es negativo, el carry se pone a 0.
|
Ejemplo: |
SUBWF
REG,1
Antes
de la instrucción:
Después de la instrucción: |
REG =
1
W = 2
REG =
0xFF
W =
0xFF |
|
SWAPF |
Intercambio de f |
|
Sintaxis: |
[label]
SWAPF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(f<3:0>) --> (dest.<7:4>)
(f<7:4>) --> (dest.<3:0>) |
Flags afectados: |
Ninguno |
Descripción: |
Los
cuatro bits de más peso del registro "f" se intercambian con los cuatro
bits de menos peso del mismo registro. Si "d" es 0, el resultado se
coloca en el registro W. Si "d" es 1, el resultado queda en el registro
"f".
|
Ejemplo: |
SWAPF
REG,0
Antes
de la instrucción:
Después de la instrucción: |
REG =
0x5A
REG =
0x5A
W =
0xA5 |
|
TRIS |
Carga registro TRIS |
|
Sintaxis: |
[label]
TRIS f |
Operandos: |
5 <= f <= 7 |
Operación: |
(W) --> Registro
TRIS "f" |
Flags afectados: |
Ninguno |
Descripción: |
El
contenido del registro W se carga en uno de los tres registros TRIS
(TRISA, TRISB, TRISC) según "f" valga 5, 6 ó 7 respectivamente. Los
registros TRIS se emplean para configurar cada una de las puertas A, B ó
C para que actúen sus líneas como entrada o salida.
|
Ejemplo: |
TRIS
PORTA
Antes
de la instrucción:
Después de la instrucción: |
W =
0xA5
TRISA
= 0xA5 |
|
XORLW |
W XOR literal |
|
Sintaxis: |
[label]
XORLW k |
Operandos: |
0 <= k <= 255 |
Operación: |
(W).XOR.K --> (W) |
Flags afectados: |
Z |
Descripción: |
Realiza la función lógica OR exclusiva (EOR) entre el contenido del
registro W y la constante "k" de 8 bits. El resultado se almacena en el
registro W.
|
Ejemplo: |
XORLW
0xAF
Antes
de la instrucción:
Después de la instrucción: |
W =
0xB5
W =
0x1A |
|
XORWF |
W XOR f |
|
Sintaxis: |
[label]
XORWF f,d |
Operandos: |
0 <= f <= 31; d = 0
ó d = 1 |
Operación: |
(W).XOR.(f) --> (dest.) |
Flags afectados: |
Z |
Descripción: |
Realiza la función lógica OR exclusiva (EOR) entre 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 resultado se almacena en el registro "f".
|
Ejemplo: |
XORWF
REG,1
Antes
de la instrucción:
Después de la instrucción: |
REG =
0xAF
W =
0xB5
REG =
0x1A
W =
0xB5 |
|
|
|
|