Nemonicos de Gama Media de Microchip PDF

Nemónicos de la gama media de Microchip
1. Nemónico
En la siguiente tabla se detallan los 35 nemónicos de la gama media de Microchip, cuando
se indica borra en la descripción se quiere decir que se pone a 0 el mismo.
W es el acumulador, f representa un registro cualquiera y C,DC,Z los flags del registro
STATUS.
OPERACIONES TIPO BYTE A REGISTROS (FILE REGISTER)
Nemónico, 14 bits Opcode Flag
Descripción Ciclos Notas
Operandos B+S B-S afectado
ADDWF f, d Sumar W y f 1 00 0111 dfff ffff C,DC,Z 1, 2
ANDWF f, d AND W con f (bit a bit) 1 00 0101 dfff ffff Z 1,2
CLRF f Borrar f 1 00 0001 lfff ffff Z 2
CLRW - Borrar W 1 00 0001 0xxx xxxx Z -
COMF f, d Complemento de f (bit a bit) 1 00 1001 dfff ffff Z 1,2
DECF f, d Decrementar f 1 00 0011 dfff ffff Z 1,2
DECFSZ f, d Decrementar f, Saltar si 0 1 (2) 00 1011 dfff ffff - 1,2,3
INCF f, d Incrementar f 1 00 1010 dfff ffff Z 1,2
INCFSZ f, d Incrementar f, Saltar si 0 1 (2) 00 1111 dfff ffff - 1,2,3
IORWF f, d OR W con f (bit a bit) 1 00 0100 dfff ffff Z 1,2
MOVF f, d Mover f 1 00 1000 dfff ffff Z 1,2
MOVWF f Mover de W a f 1 00 0000 lfff ffff - -
NOP - No Operar 1 00 0000 0xx0 0000 - -
RLF f, d Rotar a la izquierda f por Carry 1 00 1101 dfff ffff C 1,2
RRF f, d Rotar a la derecha f por Carry 1 00 1100 dfff ffff C 1,2
SUBWF f, d Restar W a f 1 00 0010 dfff ffff C,DC,Z 1,2
SWAPF f, d Intercambiar nibbles de f 1 00 1110 dfff ffff - 1,2
XORWF f, d XOR W con f (bit a bit) 1 00 0110 dfff ffff Z 1,2
OPERACIONES DE MANIPULACION E INTERROGACION DE BIT EN REGISTRO
BCF f, b Borrar Bit de f 1 01 00bb bfff ffff - 1,2

BSF f, b Activar Bit de f 1 01 01bb bfff ffff - 1,2
BTFSC f, b Test de Bit de f, Saltar si ‘0’ 1 (2) 01 10bb bfff ffff - 3
BTFSS f, b Test de Bit de f, Saltar si ‘1’ 1 (2) 01 11bb bfff ffff - 3
OPERACIONES CON LITERALES (CONSTANTES) Y DE CONTROL
ADDLW k Sumar literal a W 1 11 111x kkkk kkkk C,DC,Z -

ANDLW k AND de literal con W 1 11 1001 kkkk kkkk Z -
CALL k Llamada a subrutina 2 10 0kkk kkkk kkkk - -
CLRWDT - Borrar timer del Watchdog 1 00 0000 0110 0100 TO’,PD’ -
GOTO k Ir a dirección 2 10 1kkk kkkk kkkk - -
IORLW k OR de literal con W 1 11 1000 kkkk kkkk Z -
MOVLW k Mover literal a W 1 11 00xx kkkk kkkk - -
RETFIE - Regresar desde interrupción 2 00 0000 0000 1001 - -
RETLW k Regresar con literal en W 2 11 01xx kkkk kkkk - -
RETURN - Regresar desde Subrutina 2 00 0000 0000 1000 - -
SLEEP - Pasar a modo standby 1 00 0000 0110 0011 TO’,PD’ -
SUBLW k Restar W a un literal 1 11 110x kkkk kkkk C,DC,Z -
XORLW k XOR de literal con W 1 11 1010 kkkk kkkk Z -
Nota
1: Cuando los registro de entrada/salida son modificados por la función ( Ej., MOVF PORTB, 1), el valor será al que
represente en los pines. Por ejemplo si el latch esta a 1 los pines estarán configurados como entrada, si estos pines están
puestos a 0 por un dispositivo externo, el dato se escribirá como ‘0’.
2: Si esta instrucción es ejecutada en el registro TMR0 (y cuando sea aplicable d=1), el conteo de la preescala asignada
será borrado, pero no será borrada la preescala asignada en OPTION_REG, que controla Timer0.
3: Si el contador de programa es modificado o la condición de test es cierta, la instrucción durará 2 ciclos, el Segundo
será una operación NOP
Página 1 de 15
Nemónicos de la serie media de Microchip
2. Introducción.
Para la comprensión de este documento hay que aprender unas nociones básica de
notación, que a continuación se describen.
Advierto de antemano que por sí solo este código no funcionará, ya que se obvian las
directivas del compilador.
Estos ejemplos están pensados para MPLAB 5.40.00, detallare seguidamente la
representación de constantes en este compilador.
Tipo Sintaxis Ejemplo Comentario
Decimal D’<dígitos>’ D’100’ (D puede ser minúscula)

.<dígitos> .100
Hexadecimal H’<digito hex.>’ H’64’ (H puede ser minúscula)
0x<digito hex.> 0x64
<digito hex.> 64
Octal O'<digito octal>’ O’144’ (O puede ser minúscula)
binario B’<digito binario>’ B’01100100’ (B puede ser minúscula)
ASCII A’<carácter>’ A’C’ (A puede ser minúscula)
‘<carácter>’ ‘C’
En otros compiladores se puede utilizar la siguiente nomenclatura
Tipo Sintaxis Ejemplo Comentario
Decimal 0D<dígitos> 0D100 (D puede ser minúscula)

<dígitos> 100 (Suele ser en compiladores de
C)
Hexadecimal 0H<digito hex.> 0H64 (H puede ser minúscula)
Octal 0O<digito octal> 0O144 (O puede ser minúscula)
binario 0B<digito binario> 0B01100100 (B puede ser minúscula)
Los registros y literales se denotan de la siguiente manera:
- f : Representa un registro cualquiera de la memora SRAM

- k : Representa una constante de 8 bits.
- d : Representa los valores 0 ó 1 (no es asociable a un registro).
- b : Es un valor entre 0 y 7 (no es asociable a un registro).
Flags:
Los Flags o banderas son marcadores, representados por bits dentro del registro de
STATUS, serán afectados por los registros que así lo indique la tabla anterior y son:
- Z : Flag de cero. Se pone a 1 cuando una operación que le afecta da como resultado
un 0.
- C : Flag de Carry, se pone a 1 cuando la operación que le afecta sobrepasa el nivel
de representación del procesador, en nuestro caso es 8 BIT’s , de esta manera si
sumamos a 0b11111111 un 0b00000011 el resultado seria 0b00000010 y el BIT de
Carry pasaría a 1.
- DC : Flag de carry del nibbles inferior, este se comporta igual que el BIT de Carry,
solo que el limite de representación son los 4 bits inferiores, de esta manera si
tenemos 0b00001111 y sumamos 0b00000111, l resultado será 0b00010110 y el
BIT de DC se pone a 1, el BIT de Carry estará a 0 al no superarse los 8 bits y el de Z
a 0 al ser el número diferente de 0.
Página 2 de 15
Registros:
Un registro es un espacio en la memoria SRAM del microcontrolador en el que podemos

guardar información, existen también unos registros en los cuales podemos configurar el
microcontrolador o saber el estado de este o algunos de sus periféricos.
Un registro está compuesto por 8 bits los cuales se representan dándoles un numero según
su posición, de esta manera el BIT menos representativo se le da el número 0 y el mas
representativo el 7.
BIT 7 6 5 4 3 2 1 0
REGISTRO X X X X X X X X
Donde X puede ser 1 ó 0.
Los bits del 0 al 3 se denomina nibbles inferior, y del 4 al 7 se denominan nibbles superior.
La forma de representación de parte de los bits de un registro en este documento es la

siguiente.
Registro<3:0>
Indica los bits del 3 al 0 del registro.
Para identificar el BIT Z de STATUS sería.
STATUS<2>
Macro:
En la mayoría de los compiladores existen algunas utilidades extra como por ejemplo
los macro, estos macro son una forma de realizar diversas rutinas. De esta manera un
macro representa un grupo de operaciones. Cuando se ensambla el código se sustituye la
etiqueta del macro por las operaciones que representa.
Como por ejemplo un cambio en la página de memoria o de memoria de programa.
3. Descripción de nemónicos
A continuación realizaré un descripción de los nemónicos adjuntando una ejemplo simple y

cambio de estados en registros.
Página 3 de 15
ADDLW: Sumar literal a W (ADD Literal to W)
Sintaxis: [ etiqueta ] ADDLW k
Operando: 0 ≤ k ≤ 255
Operación: (W) + k → (W)
Afecta a los flags: C, DC, Z
Descripción: El contenido de W es sumado con los 8 bits del literal k y el resultado se coloca en W.
Ej. En este ejemplo se suma 0x05 (5 en decimal) al contenido de W, que este caso es 0x10 de alguna operación
anterior (mirar MOVLW para ver como cargar un literal en W).
SUMA5 ;SUMA5 es una etiqueta que identifica la posición del código

ADDLW 0x05 ;W=0x10
;W=0x15
ADDWF: Sumar W y f (ADD W to F)

Sintaxis: [ etiqueta ] ADDWF f, d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (W) + (f) → (destino)
Descripción: Suma el contenido de W con el registro f. Si d es 0, el resultado es colocado en W, si d es 1 el

resultado se coloca de nuevo en f.
Ej. Vamos a sumar a W el registro DATO , denotado por esta etiqueta, el valor inicial de este registro es 0x23 y
realizaremos dos casos, en el que d es igual a 1 ó 0 representado por W. W tendrá valor inicial 0x2A.
Mirar las operaciones MOVLW y MOVWF para dar un valor a f.
CASO1 ;es una etiqueta que identifica la posición del código

ADDWF DATO,W ;W = 0x2A _ DATO = 0x23 mandaremos el resultado a W
;W = 0x4D _ DATO = 0x23 en W s encuentra la suma
CASO2 ;es una etiqueta que identifica la posición del código

ADDWF DATO,1 ;W = 0x2A _ DATO = 0x23 mandaremos el resultado a DATO
;W = 0x2A _ DATO = 0x4D en W s encuentra la suma
ANDLW: AND de literal con W (AND Literal to W)

Sintaxis: [ etiqueta ] ANDLW k
Operandos: 0 ≤ k ≤ 255
Operación: (W) .AND. (k) → (W)
Afecta a los flags: Z
Descripción: Con el contenido del acumulador W se realiza la operación AND BIT a BIT con el literal, el resultado
se guarda en W.
Ej. Vamos a realizar la operación AND para obtener el nibbles inferior del acumulador, que inicialmente es 0x7A.
NIBBLESINF ;es una etiqueta que identifica la posición del código

ANDLW 0x0F ;W = 0x7A Se realizara la operación booleana AND
;W = 0x0A Tenemos el nibbles inferior de W
ANDWF: AND W con f (AND W to F)

Sintaxis: [etiqueta ] ANDWF f, d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (W) .AND. (f) → (destino)
Descripción: Operación AND de W con el registro f, si d es 0 el resultado se coloca en W, si es 1 el resultado se

coloca en f.
Ej. En este caso realzaremos la operación AND del registro ENTRADAS con W, el valor inicial e ENTRADAS es
0b11000011 y el valor W es 0b01101110 en binario
ANDOPERACION1 ;es una etiqueta que identifica la posición del código

ANDWF ENTRADAS,0 ;W = 0b11000011 ENTRADAS = 0b01101110
;W = 0b01000010 ENTRADAS = 0b01101110
Página 4 de 15
ANDOPERACION2 ;es una etiqueta que identifica la posición del código
ANDWF ENTRADAS,1 ;W = 0b11000011 ENTRADAS = 0b01101110
;W = 0b11000011 ENTRADAS = 0b01000010
BCF: Borrar Bit de f (Bit Clear F)

Sintaxis: [ etiqueta ] BCF f, b
Operandos: 0 ≤ f ≤ 127 0≤b≤7
Operación: 0 → (f<b>)
Afecta a los flags: Ninguno
Descripción: El BIT b en el registro f es puesto a cero.
Ej. Pondremos a 0 el BIT 0 del registro DATO, anteriormente se le dio el valor 0xFF.
BORRABIT ; es una etiqueta que identifica la posición del código

BCF DATO,0 ; DATO = 0b11111111
; DATO = 0b11111110
BSF: Activar Bit de f (Bit Set F)

Sintaxis: [ etiqueta ] BSF f, b
Operandos: 0 ≤ f ≤ 127 0≤b≤7
Operación: 1 → (f<b>)
Descripción: El BIT b en el registro f es puesto a uno.
Ej. Se pondrá a 1 el BIT 5 del registro STATUS, no nos interesara el estado anterior de este registro.
ACTBIT ;es una etiqueta que identifica la posición del código

BSF STATUS,5 ; STATUS = 0bxx0xxxxx
; STATUS = 0bxx1xxxxx
BTFSC: Test de Bit de f, Saltar si ‘0’ (Bit Test, Skip if Clear)

Sintaxis: [ etiqueta ] BTFSC f, b
Operandos: 0 ≤ f ≤ 127 0≤b≤7
Operación: saltar si (f<b>) = 0
Descripción: Si el BIT b en el registro f es 1, la próxima instrucción es ejecutada. Si es BIT b en el registro f es 0,

la próxima instrucción es descartada y en su lugar se ejecuta una instrucción NOP, haciendo que BTFSC dure
dos ciclos de programa.
Ej. Pondremos dos ejemplos de esta instrucción para denotar la potencialidad de esta.
En el 1º se realizará un bucle del que no se saldrá hasta que el dato tenga valor diferente de 0.
En el 2º se realizará o no una operación, dependiendo del resultado de test.
EJ1 ; es una etiqueta que identifica la posición del código

XXXX ; operaciones cualesquiera para realizar la comprobación
BTFSC STATUS,Z ;se realiza test de flag Z
GOTO EJ1 ; Nemónico de salto, mirar descripción de este, salta a la etiqueta EJ1
XXXX ; operaciones siguientes

BTFSC STATUS,Z ;se realiza test de flag Z
GOTO FIN ; Nemónico de salto, mirar descripción de este, salta a la etiqueta FIN
FIN ; es una etiqueta que identifica la posición del código
Página 5 de 15
BTFSS: Test de Bit de f, Saltar si ‘1’ (Bit Test f, Skip if Set)

Sintaxis: [ etiqueta ] BTFSS f, b
Operandos: 0 ≤ f ≤ 127 0≤b<7
Operación: Saltar si (f<b>) = 1
Descripción: Si el BIT b en el registro f es 0, la próxima instrucción es ejecutada. Si el BIT b está a 1 la próxima

instrucción es descartada y en su lugar se ejecuta el Nemónico NOP, por lo tanto en este último caso la
instrucción dura 2 ciclos de programa.
Ej. Pondremos los mismos ejemplos aplicados a registros diferentes
TEST1 ; es una etiqueta que identifica la posición del código

REPITE ; es una etiqueta que identifica la posición del código
BTFSS PORTA,0 ; realiza un test sobre el bit 0 de PORTA
GOTO REPITE ; si esta a 0 se realiza esta operación, si no realiza un NOP
XXXX ; otras operaciones
TEST2 ; es una etiqueta que identifica la posición del código

BTFSS PORTA,0 ; realiza un test sobre el bit 0 de PORTA
GOTO NOPULSADO ; si esta a 0 salta a NOPULSADO, si esta a 1 realiza un NOP
NOPULSADO ; es una etiqueta que identifica la posición del código
CALL: Llamada a subrutina (CALL Subroutine)

Sintaxis: [ etiqueta ] CALL k
Operación: (PC)+ 1→ TOS
k → PC<10:0>
(PCLATH<4:3>) → PC<12:11>
Afecta a los flags: ninguno
Descripción: la instrucción CALL, realiza llamada a una subrutina, primero pone el contador de programa en la
pila, los primeros 11 bits son cargados en el contador de programa y luego los 2 restantes del PCLATH. CALL es
una subrutina de dos ciclos.
El literal k denota la dirección absoluta de una instrucción con respecto a una página, la forma mas cómoda de
realizar un CALL es poner como k el nombre de una etiqueta, en el precompilado se sustituyen por las
direcciones.
El valor k de 2047 no es caprichoso, la memoria de programa de estos microcontroladores está dividida en
páginas, es como un libro. Los códigos se escriben en páginas, el tamaño de estas es de 2048 comandos, como
por ejemplo el PIC6F876 tiene 4 páginas. El PIC16F84 y PIC16F84A tiene una sola página, aunque de tamaño
1024.
Para realizar un CALL a cualquier página habrá que configurar primero los bits 4:3 del PCLATH, donde
pondremos la página a donde queremos realizar el salto.
Para regresar de esa subrutina no tendremos que realizar ninguna configuración de PCLATH, ya que se
recupera completamente la dirección de regreso de la pila de programa.
Ej realizamos una llamada a subrutina en la página 1 , para cargar el contenido de PCLATH utilizamos un macro
de MPLAB

Pagina1 ; mediante macro configuramos PCLATH
CALL SUBRUTINA1 ; se realiza llamada a subrutina
XXX ; instrucción que se ejecutara cuando se termine la
XXX ; subrutina
....... ;
SUBRUTINA1 ; es una etiqueta que identifica la posición del código
XXX ;
Página 6 de 15
CLRF: Borrar f (CLeaR F)

Sintaxis: [ etiqueta ] CLRF f
Operandos: 0 ≤ f ≤ 127
Operación: 00h → (f)
1→Z
Descripción: El contenido del registro f es borrado (puesto a 0) y el flag Z es activado.
Ej. Bueno pondré un ejemplo aunque no sea necesario. Supongamos que el valor inicial de DATO es 0xF0,
después de borrarlo se pone a uno el flag Z.
ETIQUETA ; es una etiqueta que identifica la posición del código

XXX ; DATO = 0xF0
CLRW DATO ; DATO = 0x00 Z = 1
CLRW: Borrar W (CLeaR W)

Sintaxis: [ etiqueta ] CLRW
Operandos: Ninguno
Operación: 00h → (W)
1→Z
Descripción: El acumulador W es borrado (puesto a 0) y el flag Z es activado.
Ej. Supongamos que el valor debido a operaciones anteriores es 0xF0, se utilizará CRW para ponerlo a 0x00.
EJ ; es una etiqueta que identifica la posición del código

XXX ; W = 0xF0
CLRW ; W = 0x00 Z=1
CLRWDT: Borrar timer del Watchdog (CLeaR WatchDog Timer)

Sintaxis: [ etiqueta ] CLRWDT
Operandos: Ninguno
Operación: 00h → WDT
0 → WDT preescala
1 → TO
1 → PD
Afecta a los flags: TO, PD
Descripción: Esta instrucción pone a 0 el Watchdog timer, y pone a 0 la preescala, además de poner a 1 los flags
de TO y PD del registro STATUS.
La preescala puede verse en MPLAB como T0pre, siendo esta solo asignable al timer0 o al watchdog.
El watchdog o perro guardián es un método muy extendido para poder evitar el cuelgue del microcontrolador, es
imperativo para cualquier sistema industrial, ya que no nos podemos permitir fallos o paradas peligrosas en un
proceso de producción, que pueden quedar afectados tanto las personas a cargo del proceso industrial como la
materia prima o semielaborada que esos momentos este siendo procesada, con la consiguiente perdida de
dinero.
Ej. En el caso en el que el reset por watchdog este habilitado para evitar el reset se deberá borrar el WDT de
forma frecuente.
ETKT ; es una etiqueta que identifica la posición del código

XXX ; instrucción del proceso
XXX ; instrucción del proceso
CLRWDT ; se debe colocar esta instrucción de foma temporizada para que sea los mas
XXX ; efectiva posible
COMF: Complemento de f (bit a bit) (COMplement F)

Sintaxis: [ etiqueta ] COMF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f’) → (destino)
Página 7 de 15
Descripción: El contenido del registro f es complementado (se realiza operación NOT BIT a BIT), el resultado se
coloca en el acumulador si d es 0 ó colocado nuevamente en el registro f si es 1.
Ej. Se realizara el complemento de u operación NOT BIT a BIT, de DATO. Con las dos posibilidades de d.

COMF DATO,1 ; DATO = 0b01010101
XXX ; DATO = 0b10101010

COMF DATO,0 ; DATO = 0b01010101
XXX ; DATO = 0b01010101 W = 0b10101010
DECF: Decrementar f (DECrement f)

Sintaxis: [ etiqueta ] DECF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f) - 1 → (destino)
Descripción: Decrementa el registro f, si d es 0 el resultado se coloca en el acumulador, si d es 1 se coloca en el

registro f.
Ej. Decrementaremos el registro COUNT. Con las dos posibilidades de d.

DECF COUNT,1 ; COUNT = 0xB1
XXX ; COUNT = 0xB0

XXX ; COUNT = 0xB1 W = 0xB0
DECFSZ: Decrementar f, Saltar si 0 (DECrement F, Skip if Zero)

Sintaxis: [ etiqueta ] DECFSZ f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f) - 1 → (destino)
Saltar si resultado = 0
Descripción: El contenido del registro f es decrementado, si d es 0 se coloca en el acumulador, si es 1 se vuelve

a poner en el registro f.
Si el resultado de decrementar es 0, la siguiente instrucción se sustituirá por un NOP(instrucción de 2 ciclos), en
caso contrario la siguiente instrucción es ejecutada.
Ej. El primer ejemplo realiza una espera de tantos ciclos de operación como indique ESPERA.
El segundo ejemplo Decrementa un dato y lo deja en el acumulador, si el resultado de decrementar fue 0 se salta
a DATOERROR, si no es así se sigue operando.

; ESPERA = 0x05
DECFSZ ESPERA,1 ;
GOTO EJ1 ; ESPERA = ESPERA - 1
XXXX ; ESPERA = 0x00
TERMINA ; es una etiqueta que identifica la posición del código
DECFSZ DATO,0 ; ESPERA
GOTO DATOENW ; Se ejecuta si ESPERA ≠ 0
GOTO DATOERROR ; Se ejecuta se ESPERA = 0
Página 8 de 15
GOTO: Ir a dirección (GO TO)

Sintaxis: [ etiqueta ] GOTO k
Operación: k → PC<10:0>
PCLATH<4:3> → PC<12:11>
Descripción: este Nemónico realiza un salto incondicional (salta y punto no realiza ningún tipo de test).
Los 11 bits de menos peso son guardados en el contador de programa PC<10:0> y el PCLATH <4:3> se pasa al
contador de programa, esta instrucción se realiza en dos ciclos de programa.
Al igual que la subrutina CALL ésta realiza saltos no mas grandes que 2047 líneas en modo absoluto con
respecto a las páginas, que corresponde a una página de la memoria de programa. En todo momento se deberá
configurar PCLATH, que por defecto es 0x00.
Ej: el primer ejemplo salta a la página 1 de por ejemplo un 16f876. se utiliza un macro para configurar el
PCLATH.

pagina1 ; MACRO de MPLAB
GOTO PAKA ; salta a PAKA
.......... ;
PAKA ; es una etiqueta que identifica la posición del código
XXXX ; código cualquiera
INCF: Incrementar f (INCrement F)

Sintaxis: [ etiqueta ] INCF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f) + 1 → (destino)
Descripción: El contenido del registro f es incrementado. Si d es 0 el resultado es colocado en el acumulador W,

si d es 1 el resultado es puesto nuevamente en f.
Ej. incrementaremos el registro COUNT. Con las dos posibilidades de d.

XXX ; COUNT = 0xB0

XXX ; COUNT = 0xB1 W = 0xB0
INCFSZ: Incrementar f, Saltar si 0 (INCrement F, Skip if Zero)

Sintaxis: [ etiqueta ] INCFSZ f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f) + 1 → (destino)
Saltar si resultado = 0
Descripción: El contenido de f es incrementado. Si d es 0 el resultado es colocado en W, si f es 1 el resultado es

colocado de nuevo en f.
Si el resultado del incremento es diferente de 0, la siguiente instrucción se ejecuta. Si el resultado de incremento
es 0 en lugar de la siguiente instrucción se ejecuta un NOP, en este ultimo caso la instrucción es ejecutada en
dos ciclos de programa.
Página 9 de 15
Ej. El primer ejemplo realiza una espera de tantos ciclos de operación como indique (ESPERA-255).
El segundo ejemplo Incrementa un dato y lo deja en el acumulador, si el resultado de incrementar fue 0 se salta a
DATOERROR, si no es así se sigue operando.

; ESPERA = 0x05
INCFSZ ESPERA,1 ;
GOTO EJ1 ; ESPERA = ESPERA + 1
XXXX ; ESPERA = 0x00
TERMINA ; es una etiqueta que identifica la posición del código
INCFSZ DATO,0 ; ESPERA
GOTO DATOENW ; Se ejecuta si ESPERA ≠ 0
GOTO DATOERROR ; Se ejecuta se ESPERA = 0
IORLW: OR de literal con W (Inclusive OR Literal with W)

Sintaxis: [ etiqueta ] IORLW k
Operación: (W) .OR. k → (W)
Descripción: Se realiza la operación OR BIT a BIT del registro W con el literal k. El resultado es colocado en el
acumulador W.
Ej. Realizaremos la operación OR de W que tendrá el valor 0b00100110 con el literal k igual a 0b10100001.

IORLW 0b10100001 ; W = 0b00100110
XXX ; W = 0b10100111
IORWF: OR W con f (bit a bit) (Inclusive OR W with F)

Sintaxis: [ etiqueta ] IORWF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (W) .OR. (f) → (destino)
Descripción: Se realiza la operación OR del acumulador W con el registro f. Si d es 0 el resultado se coloca en el

acumulador W, si es 0 se vuelve a poner en f.
Ej. Realizaremos la operación OR de W que tendrá el valor 0b00101110 con el registro REG igual a
0b11110001.

IORWF REG,0 ; W = 0b00101110 REG = 0b011110001
XXX ; W = 0b11111111 REG = 0b011110001
MOVF: Mover f (MOVe F)

Sintaxis: [ etiqueta ] MOVF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f) → (destino)
Descripción: El contenido del registro f es movido, su destino depende de d.

Si d es 0 f se mueve al acumulador, si d es 1 el contenido del registro es colocado nuevamente en f (aunque
parece una inutilidad este ultimo caso, puede ser utilizado para saber si el contenido del registro f es cero, ya que
esta instrucción afecta al flag Z).
Ej. En el primero veremos si DATO es 0, en ese caso Z pasara a 1. En el segundo moveremos el registro
PORTB a W.

MOVF DATO,1 ;DATO = 0x00 Z=0
XXX ;DATO = 0x00, Z = 1
Página 10 de 15
MOVF PORTB,0 ; PORTB = 0x80 W = 0x00
XXX ; PORTB = 0x80 W = 0x80
MOVLW: Mover literal a W (MOVe Literal to W)

Sintaxis: [ etiqueta ] MOVLW k
Operación: k → (W)
Descripción: Los 8 bits del literal k serán escritos en el acumulador W.
Ej. Moveremos a w el valor 0x04

MOVLW 0x04 ; W = 0x00
XXX ; W = 0x04
MOVWF: Mover de W a f (MOVe W to F)

Sintaxis: [ etiqueta ] MOVWF f
Operandos: 0 ≤ f ≤ 127
Operación: (W) → (f)
Descripción: Mueve el contenido del acumulador W al registro f.
Ej. Moveremos el contenido de W al registro TRISB

MOVWF TRISB ; W = 0x01 TRISB = 0x00
XXX ; W = 0x01 TRISB = 0x01
NOP: No Operar (No OPeration)

Sintaxis: [ etiqueta ] NOP
Operandos: Ninguno
Operación: No se realiza ninguna operación.
Ej. Se puede utilizar para realizar pequeña esperas. En este caso realizaremos una espera de dos ciclos de
operación.

NOP ; espera 1 ciclo de operación
NOP ; espera 1 ciclo de operación
RETFIE: Regresar desde interrupción (RETurn From IntErrupt)

Sintaxis: [ etiqueta ] RETFIE
Operandos: Ninguno
Operación: TOS → PC
1 → GIE
Descripción: se regresa de una subrutina de interrupción.

Se realizan las operaciones de recarga del contador de programa desde la pila y se activan de nuevo las
interrupción.
Por si sola esta instrucción no es recomendable para ser utilizada como regreso de interrupción, debe utilizarse
junto con otras instrucciones para poder guardar el registro de STATUS y W.
Ej. Regresaremos de una interrupción después de ejecutarla.

XXX ; subrutina de interrupción
RETFIE ; se ejecutara el regreso de la interrupción
Página 11 de 15
RETLW: Regresar con literal en W (RETurn with Literal in W)
Sintaxis: [ etiqueta ] RETLW k
Operación: k → (W)
TOS → PC
Descripción: El acumulador es cargado con el valor k. Se carga el contador de programa con el de la pila y se
regresa al lugar donde se realizo el CALL. Se emplean dos ciclos de proceso para esta instrucción.
Ej. En algunos casos necesitamos que una subrutina nos devuelva el resultado de una acción, como por ejemplo
un 1 si se cumple una razón o 0 si no se cumple, en este caso realizaremos la parte que comunica el
cumplimiento de la razón. Otra utilidad aún más potente seria utilizarlo como sistema de lectura de datos en
memoria de programa. Solo indicare la primera utilidad.

XXX ; La subrutina halla que se cumple
RETLW 0x01 ; regresa con un 1 en el acumulador
RETURN: Regresar desde Subrutina (RETURN from Subroutine)

Sintaxis: [ etiqueta ] RETURN
Operandos: Ninguno
Operación: TOS → PC
Descripción: Regresa de la subrutina, la parte superior de la pila es colocada en el contador de programa. Esta
una instrucción de dos ciclos de programa.
Ej. En este caso simplemente se regresa de la subrutina, pudiendo colocar lo que queramos en W. Es siempre
recomendable hacer que las subrutina acaben en el mismo sitio, esto es hacer que una subrutina solo tenga un
RETURN.

XXX ; fin de subrutina
RETURN ; regreso de subrutina
RLF: Rotar a la izquierda f por Carry (Rotate Left F through carry)

Sintaxis: [ etiqueta ] RLF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: Ver descripción siguiente
Afecta a los flags: C
Descripción: El contenido del registro f es rotado un BIT a la izquierda , el BIT que sale por la izquierda se pasa
al carry, y el del carry se pasa al BIT 0 de f, como se indica en la figura
EJ La rotación de un registro tiene múltiples aplicaciones, en este caso lo utilizaremos como sistema de
multiplicación, si realizamos una rotación a izquierda conseguiremos multiplicar por 2 el contenido del registro.
E registro a otra sera DATO = 40 = 0b00101000

BCF STATUS,Z ; ponemos a 0 el carry para que nos meta un cero en el BIT bajo de DATO
RLF DATO,1 ; rotamos DATO DATO = 0b00101000 = 40
XXX ; DATO = 0b01010000 = 80
RRF: Rotar a la derecha f por Carry (Rotate Right F through carry)

Sintaxis: [ etiqueta ] RRF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: Ver descripción siguiente
Afecta a los flags: C
Descripción: El contenido del registro f es rotado un BIT a la derecha , el BIT que sale por la derecha se pasa al
carry, y el del carry se pasa al BIT 7 de f, como se indica en la figura
Página 12 de 15
EJ La rotación de un registro tiene múltiples aplicaciones, en este caso lo utilizaremos como sistema de división,
si realizamos una rotación a derecha conseguiremos dividir por 2 el contenido del registro. En este caso se
pierde los decimales.
E registro a otra sera DATO = 40 = 0b00101000

BCF STATUS,Z ; ponemos a 0 el carry para que nos meta un cero en el BIT alto de DATO
RRF DATO,1 ; rotamos DATO DATO = 0b00101000 = 40
XXX ; DATO = 0b00010100 = 20
SLEEP: Pasar a modo standby

Sintaxis: [ etiqueta ]SLEEP
Operandos: Ninguno
Operación: 00h → WDT
0 → WDT preescala
1 → TO’
0 → PD’
Afecta a los flags: TO’, PD’
Descripción: El BIT PD’ (Power-down) es borrado, el BIT TO’ (Time-out) es puesto a 1. El watchdog timer es
puesto a cero y el contenido de su preescala también, el microcontrolador es puesto en modo SLEEP y el
oscilador es parado. Se saldrá de este estado cuando se produzca un RESET, un RESET por Watchdog o
cuando se produzca una interrupción que afecte a este estado.
Ej. Simplemente pasará el microcontrolador a modo sleep

XXX ; instrucción cualquiera
SLEEP ; Paso a modo sleep y el reloj se para.
SUBLW: Restar al literal el W (SUBtract W from Literal)

Sintaxis: [ etiqueta ] SUBLW k
Operación: k - (W) → (W)
Descripción: Se resta el acumulador W al literal k por el método del complementa A2.

Explicare que método es éste.
El complemento A2 es una manera de representar números tanto negativos como positivos.
De esta manera para representar un número como positivo se coloca tal cual sin realiza ninguna modificación, y
para representarlo como negativo se realiza la siguiente operación :
C A2 (− A) = 2 8 − A = 256 − A
esta se realiza en el microcontrolador de forma automática, ya que es simplemente una operación Not y un
incremento de A.
De esta manera si queremos restar a B el valor de A seria de la siguiente manera.
( )
X = B − A = B + C A2 (− A) = A + 28 − A = B + (256 − A)
pondremos 3 ejemplos trabajando con números hexadecimales, sacaremos conclusiones y los flags afectados.
VALORES Hexadecimal sin CA2 Hexadecimal con CA2 FLAG

CASO
A B OP RES OPCA2 RESCA2 BYTE1 BYTE0 Z C
A>B 50 30 50 – 30 20 50 + D0 120 1 20 0 1
A=B 40 40 40 – 40 0 40 + C0 100 1 00 1 1
A<B 30 50 30 – 50 -20 30 + B8 E0 0 E0 0 0
Nota: E0 es un número negativo si realizamos el proceso inverso nos tendría que dar –20
100 - E0 = 20, que al aplicársele el complemento A2 para números negativos es el –20.
Ej. En este caso realizaremos los 3 ejemplos anteriormente detallados.

SUBLW 0x50 ; W = 0x30
XXX ; W = 0x20 C=1 Z=0

SUBLW 0x40 ; W = 0x40
XXX ; W = 0x00 C=1 Z=1
Página 13 de 15
SUBLW 0x30 ; W = 0x50
XXX ; W = 0xE0 C=0 Z=0
SUBWF: Restar W a f (SUBtract W from F)

Sintaxis: [ etiqueta ] SUBWF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f) - (W) → (destino)
Descripción: Resta al registro f el contenido del acumulador W, utilizando el sistema del complemento A2 (mirar
nemónico anterior para explicación CA2). Si el valor de d es 0 el resultado es colocado es colocado en el
acumulador, si d es 1 el resultado se pondrá nuevamente en f.
Ej. En este caso realizaremos similares operaciones al caso anterior. El dato al que se le restara W es DATO

SUBWF DATO,0 ; W = 0x30 DATO = 0x50
XXX ; W = 0x20 DATO = 0x50 C=1 Z=0

XXX ; W = 0x40 DATO = 0x00 C=1 Z=1

XXX ; W = 0xE0 DATO = 0x30 C=0 Z=0
SWAPF: Intercambiar nibbles de f (SWAP nibbles in F)

Sintaxis: [ etiqueta ] SWAPF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (f<3:0>) → (destino<7:4>)
(f<7:4>) → (destino<3:0>)
Descripción: El nibbles inferior y superior del registro f son intercambiados. Si d es 0 el resultado se coloca en el
acumulador W y si es 1 se coloca nuevamente en f.
Ej. Rotaremos el registro DATO, su contenido inicial será 0x40

SWAPF DATO,1 ; DATO = 0x40
XXX ; DATO = 0x04
SWAPF DATO,0 ; DATO = 0x40
XXX ; DATO = 0x40 W = 0x04
XORLW: XOR de literal con W (eXclusive OR Literal with W)

Syntax: [etiqueta] XORLW k
Operación: (W) .XOR. k → (W)
Descripción: Se realiza la operación XOR BIT a BIT del EXOR x y x⊕ y

registro W con el valor k. El resultado se coloca en W. 0 0 0
A continuación presento la tabla de la verdad de la
función EXOR. 0 1 1
1 0 1
1 1 0
Página 14 de 15
Ej. Se puede utilizar para saber si dos datos son iguales, en ese caso el resultado será 0, en el caso de que no
sea 0 los bits a 1 serán lo diferentes.

XORLW 0x08 ; W = 0x08
XXX ; W = 0x00 Z=1
XORWF: XOR W con f (bit a bit) (eXclusive OR W with F)

Syntax: [etiqueta] XORWF f,d
Operandos: 0 ≤ f ≤ 127 d ∈ [0,1]
Operación: (W) .XOR. (f) → (destino)
Descripción: Se realiza la operación XOR (mirar nemónico anterior para operación EXOR) entre el acumulador y
el registro f. Si d es 0 se coloca en W y si es 1 se deja nuevamente en f.
Ej. Se puede utilizar para saber si dos datos son iguales, en ese caso el resultado será 0, en el caso de que no
sea 0 los bits a 1 serán lo diferentes. También se utiliza para mandar un BIT que nos garantice la integridad de la
trama de datos enviados, haciendo la EXOR de cada byte con el siguiente y mandándolo.

XORWF DATO,0 ; W = 0x08 DATO = 0x08
XXX ; W = 0x00 DATO = 0x08 Z=1
XORWF DATO,1 ; W = 0x09 DATO = 0x08
XXX ; W = 0x09 DATO = 0x01 Z=0
Página 15 de 15

Nemonicos de Gama Media de Microchip PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Nemonicos de Gama Media de Microchip PDF

Cargado por

Copyright:

Formatos disponibles

Nemónicos de la gama media de Microchip

BCF f, b Borrar Bit de f 1 01 00bb bfff ffff - 1,2

OPERACIONES CON LITERALES (CONSTANTES) Y DE CONTROL

ADDLW k Sumar literal a W 1 11 111x kkkk kkkk C,DC,Z -

Tipo Sintaxis Ejemplo Comentario

Decimal D’<dígitos>’ D’100’ (D puede ser minúscula)

En otros compiladores se puede utilizar la siguiente nomenclatura

Tipo Sintaxis Ejemplo Comentario

Decimal 0D<dígitos> 0D100 (D puede ser minúscula)

Los registros y literales se denotan de la siguiente manera:

- f : Representa un registro cualquiera de la memora SRAM

Un registro es un espacio en la memoria SRAM del microcontrolador en el que podemos

La forma de representación de parte de los bits de un registro en este documento es la

A continuación realizaré un descripción de los nemónicos adjuntando una ejemplo simple y

SUMA5 ;SUMA5 es una etiqueta que identifica la posición del código

ADDWF: Sumar W y f (ADD W to F)

Descripción: Suma el contenido de W con el registro f. Si d es 0, el resultado es colocado en W, si d es 1 el

CASO1 ;es una etiqueta que identifica la posición del código

CASO2 ;es una etiqueta que identifica la posición del código

ANDLW: AND de literal con W (AND Literal to W)

NIBBLESINF ;es una etiqueta que identifica la posición del código

ANDWF: AND W con f (AND W to F)

Descripción: Operación AND de W con el registro f, si d es 0 el resultado se coloca en W, si es 1 el resultado se

ANDOPERACION1 ;es una etiqueta que identifica la posición del código

BCF: Borrar Bit de f (Bit Clear F)

Descripción: El BIT b en el registro f es puesto a cero.

BORRABIT ; es una etiqueta que identifica la posición del código

BSF: Activar Bit de f (Bit Set F)

Descripción: El BIT b en el registro f es puesto a uno.

ACTBIT ;es una etiqueta que identifica la posición del código

BTFSC: Test de Bit de f, Saltar si ‘0’ (Bit Test, Skip if Clear)

Descripción: Si el BIT b en el registro f es 1, la próxima instrucción es ejecutada. Si es BIT b en el registro f es 0,

EJ1 ; es una etiqueta que identifica la posición del código

EJ2 ; es una etiqueta que identifica la posición del código

BTFSS: Test de Bit de f, Saltar si ‘1’ (Bit Test f, Skip if Set)

Descripción: Si el BIT b en el registro f es 0, la próxima instrucción es ejecutada. Si el BIT b está a 1 la próxima

Ej. Pondremos los mismos ejemplos aplicados a registros diferentes

TEST1 ; es una etiqueta que identifica la posición del código

TEST2 ; es una etiqueta que identifica la posición del código

CALL: Llamada a subrutina (CALL Subroutine)

Afecta a los flags: ninguno

EJ1 ; es una etiqueta que identifica la posición del código

CLRF: Borrar f (CLeaR F)

Descripción: El contenido del registro f es borrado (puesto a 0) y el flag Z es activado.

ETIQUETA ; es una etiqueta que identifica la posición del código

CLRW: Borrar W (CLeaR W)

Descripción: El acumulador W es borrado (puesto a 0) y el flag Z es activado.

EJ ; es una etiqueta que identifica la posición del código

CLRWDT: Borrar timer del Watchdog (CLeaR WatchDog Timer)

ETKT ; es una etiqueta que identifica la posición del código

COMF: Complemento de f (bit a bit) (COMplement F)

EJ ; es una etiqueta que identifica la posición del código

EJ1 ; es una etiqueta que identifica la posición del código

DECF: Decrementar f (DECrement f)

Descripción: Decrementa el registro f, si d es 0 el resultado se coloca en el acumulador, si d es 1 se coloca en el

Ej. Decrementaremos el registro COUNT. Con las dos posibilidades de d.

EJ ; es una etiqueta que identifica la posición del código

EJ1 ; es una etiqueta que identifica la posición del código

DECFSZ: Decrementar f, Saltar si 0 (DECrement F, Skip if Zero)

Descripción: El contenido del registro f es decrementado, si d es 0 se coloca en el acumulador, si es 1 se vuelve

EJ1 ; es una etiqueta que identifica la posición del código

GOTO: Ir a dirección (GO TO)

Afecta a los flags: Ninguno