Instrucciones basicas del Microcontrolador PIC16F84A

1. INSTRUCCIONES BASICAS DEL PIC
16F84A
Luis Mendizabal

2. INSTRUCCIONES BASICAS DEL PIC
16F84A
Las características y capacidad de un procesador están definidas por
el conjunto de instrucciones que esta pone a disposición del
programador. Por tal razón, es fundamental conocer el conjunto de
instrucciones del microcontrolador que estamos utilizando en la
presente asignatura.
Si bien es cierto que se puede escribir programas para el PIC
16F84A utilizando lenguajes de alto nivel como el C o el Basic, que
permitirían tiempos de desarrollo más rápidos; en la asignatura,
orientada al estudio de los microprocesadores y su arquitectura,
estudiaremos y utilizaremos el lenguaje ensamblador del PIC
16F84A.
El PIC 16F84A comprende un conjunto de 35 instrucciones. Un
número pequeño comparado con las más de 300 instrucciones que
tiene un microprocesador como el Pentium IV de Intel

3. INSTRUCCIONES BASICAS DEL PIC
16F84A
• Clasificaremos, para su estudio, las
instrucciones del microcontrolador 16F84A
como instrucciones básicas e instrucciones
avanzadas.

4. INSTRUCCIONES BASICAS
• Dentro de estas incluimos las instrucciones
aritméticas, de movimiento, lógicas, de
complemento, de puesta en cero, de
intercambio y de rotación

5. INSTRUCCIONES DE COPIA
(MOVIMIENTO)
MOVLW Move Literal to W – Mover literal a W
Sintaxis movlw k
Operandos 0 k 255
Operación K => W
Indicadores Ninguno
Mueve los 8 bits del literal 'k' al registro de
trabajo 'W'.

6. INSTRUCCIONES DE COPIA
(MOVIMIENTO)
MOVWF Move W to f – Mover W a F
Sintaxis movwf f , d
Operandos 0 f 127 , d E {0,1}
Operación W => f
Indicadores Ninguno
Mueve el contenido del registro de trabajo 'W' al
registro 'f'.

7. INSTRUCCIONES DE COPIA
(MOVIMIENTO)
MOVF Move f – Mover F
Sintaxis movf f,d
Operandos 0 f 127, d Î [0,1]
Operación W => d
Indicadores Z
Mueve el contenido del registro 'f' al registro destino
indicado con 'd'. Si 'd=0' el destino es el registro de
trabajo 'W'. Si 'd=1' el destino es el propio registro 'f'.
El indicador 'Z' del registro 'STATUS' queda afectado:
'Z=1' si el contenido movido es CERO.

8. INSTRUCCIONES DE SUMA
ADDLW Add Literal to W – Sumar literal a W
Sintaxis addlw k
Operandos 0 k 255
Operación k + W => W
Indicadores C, DC, Z
Suma los 8 bits del literal 'k' con el registro de
trabajo 'W' y el resultado lo almacena en el
registro de trabajo 'W'.

9. INSTRUCCIONES DE SUMA
ADDWF Add W and f – Sumar W y F
Sintaxis addwf f,d
Operandos 0 f 127, d E [0,1]
Operación f + W => d
Indicadores C, DC, Z
Suma el contenido del registro 'f' al contenido del
registro de trabajo 'W' y el resultado se almacena
en el destino 'd'. Si 'd=0' el destino es el registro
de trabajo 'W'. Si 'd=1' el destino es el propio
registro 'f'.

10. INSTRUCCIONES DE SUSTRACCIÓN
SUBLW Subtract W from Literal – Restar W de
literal
Sintaxis sublw k
Operandos 0 k 255
Operación k - W => W
Indicadores C, DC, Z
Resta de los 8 bits del literal 'k' el contenido del
registro de trabajo 'W' y el resultado lo almacena
en el registro de trabajo 'W'.

11. INSTRUCCIONES DE SUSTRACCIÓN
SUBWF Subtract W from f – Restar W de F
Sintaxis subwf f,d
Operandos 0 f 127, d E [0,1]
Operación f - W => d
Indicadores C, DC, Z
Resta del contenido del registro 'f' el contenido del
registro de trabajo 'W' y el resultado se almacena
en el destino 'd'. Si 'd=0' el destino es el registro
de trabajo 'W'. Si 'd=1' el destino es el propio
registro 'f'.

12. INSTRUCCIONES DE PUESTA EN CERO
CLRW Clear W – Limpiar W
Sintaxis clrw
Operandos ninguno
Operación 0 => W
Indicadores Z
Carga cero al registro de trabajo 'W' y se
establece el indicador cero, 'Z=1'.

13. INSTRUCCIONES DE PUESTA EN CERO
CLRF Clear f – Limpiar F
Sintaxis clrf f
Operandos 0 f 127
Operación 0 => f
Indicadores Z
Carga cero al registro 'f' y se establece el
indicador cero, 'Z=1'.

14. INSTRUCCIONES DE INCREMENTO Y
DECREMENTO
DECF Decrement f – Decrementar F
Sintaxis decf f,d
Operandos 0 f 127, d ÎE[0,1]
Operación f - 1 => d
Indicadores Z
Decrementa el contenido del registro 'f'. Si 'd=0' el
destino es el registro de trabajo 'W'. Si 'd=1' el
destino es el propio registro 'f'. Si el resultado del
incremento es cero, se establece el indicador
cero, 'Z=1'.

15. INSTRUCCIONES DE INCREMENTO Y
DECREMENTO
INCF Increment f – Incrementar F
Sintaxis incf f,d
Operandos 0 f 127, d E [0,1]
Operación f + 1 => d
Indicadores Z
Incrementa el contenido del registro 'f'. Si 'd=0' el
destino es el registro de trabajo 'W'. Si 'd=1' el
destino es el propio registro 'f'. Si el resultado del
decremento es cero, se establece el indicador
cero, 'Z=1'.

16. INSTRUCCIÓN LÓGICA Y (AND)
ANDLW And Literal with W – And literal con W
Sintaxis andlw k
Operandos 0 k 255
Operación k .AND. W => W
Indicadores Z
Efectúa la operación AND de los 8 bits del literal
'k' con el registro 'W' y almacena el resultado
en 'W'. Actualiza el indicador 'Z'.

17. INSTRUCCIÓN LÓGICA Y (AND)
ANDWF And W with f – And W con F
Sintaxis andwf f,d
Operandos 0 f 127, d E [0,1]
Operación f .AND. W => d
Indicadores Z
Efectúa la operación AND del contenido del registro
'f' con el registro 'W' y almacena el resultado en
'd'. Si 'd=0‘ el destino es el registro de trabajo 'W'.
Si 'd=1' el destino es el propio registro 'f'.
Actualiza el indicador 'Z'.

18. INSTRUCCIÓN LÓGICA O – INCLUSIVA
(OR)
IORLW Inclusive OR Literal with W – Or literal con
W
Sintaxis iorlw k
Operandos 0 k 255
Operación k .OR. W => W
Indicadores Z
Efectúa la operación OR de los 8 bits del literal 'k'
con el registro 'W' y almacena el resultado en 'W'.
Actualiza el indicador 'Z'.

19. INSTRUCCIÓN LÓGICA O – INCLUSIVA
(OR)
IORWF Includive OR W with f – Or W con F
Sintaxis iorwf f,d
Operandos 0 f 127, d E [0,1]
Operación f .OR. W => d
Indicadores Z
Efectúa la operación OR del contenido del registro
'f' con el registro 'W' y almacena el resultado en
'd'. Si 'd=0' el destino es el registro de trabajo 'W'.
Si 'd=1' el destino es el propio registro 'f'.
Actualiza el indicador 'Z'.

20. INSTRUCCIÓN LÓGICA O – EXCLUSIVA
(XOR)
XORLW Exclusive OR Literal with W – Xor literal
con W
Sintaxis xorlw k
Operandos 0 k 255
Operación k .XOR. W => W
Indicadores Z
Efectúa la operación XOR de los 8 bits del literal 'k'
con el registro 'W' y almacena el resultado en 'W'.
Actualiza el indicador 'Z'.

21. INSTRUCCIÓN LÓGICA O – EXCLUSIVA
(XOR)
XORWF Exclusive OR W with f – Xor W con F
Sintaxis xorwf f,d
Operandos 0 f 127, d E [0,1]
Operación f .XOR. W => d
Indicadores Z
Efectúa la operación XOR del contenido del registro
'f' con el registro 'W' y almacena el resultado en
'd'. Si 'd=0‘ el destino es el registro de trabajo 'W'.
Si 'd=1' el destino es el propio registro 'f'.
Actualiza el indicador 'Z'.

22. INSTRUCCIÓN DE COMPLEMENTO
COMF Complement f – complementar F
Sintaxis comf f,d
Operandos 0 f 127, d E [0,1]
Operación ~f => d
Indicadores Z
Efectúa el complemento bit a bit del contenido del
registro 'f' y almacena el resultado en 'd'. Si 'd=0'
el destino es el registro de trabajo 'W'. Si 'd=1' el
destino es el propio registro 'f'. Actualiza el
indicador 'Z'.

23. INSTRUCCIÓN DE INTERCAMBIO DE
NIBBLES
SWAPF Swap Nibbles in f – Intercambiar nibbles en F
Sintaxis swapf
f,d
Operandos 0 f 127, d Î [0,1]
Operación f[3:0]=>d[7:4],f[7:4]=>d[3:0]
Indicadores ninguno
Efectúa el intercambio del nibble menos significativo con
el nibble más significativo del registro 'f' y almacena el
resultado en 'd'. Si 'd=0' el destino es el registro de
trabajo 'W'. Si 'd=1' el destino es el propio registro 'f'.
Actualiza el indicador 'Z'.

24. INSTRUCCIONES DE ROTACIÓN
RLF Rotate Left f through Carry – Rotar F a la izquierda a
través del bit de Acarreo
Sintaxis rlf f,d
Operandos 0 f 127, d E [0,1]
Operación
Indicadores C
Rota un bit a la izquierda, el contenido del registro 'f' pasando
por el indicador de acarreo 'C' y almacena el
resultado en 'd'. Si 'd=0' el destino es el registro de trabajo
'W'. Si 'd=1' el destino es el propio registro 'f'.
Actualiza el indicador 'C'.

25. INSTRUCCIONES DE ROTACIÓN
RRF Rotate Right f through Carry - Rotar F a la derecha a
través del bit de Acarreo
Sintaxis rrf f,d
Operandos 0 f 127, d E[0,1]
Operación C
Indicadores
Rota un bit a la derecha, el contenido del registro 'f'
pasando por el indicador de acarreo 'C' y almacena el
resultado en 'd'. Si 'd=0' el destino es el registro de
trabajo 'W'. Si 'd=1' el destino es el propio registro 'f'.
Actualiza el indicador 'C'.

26. DESARROLLO DE LA PRACTICA
• Escriba un programa que calcule la diferencia de dos números de 8 bits, sin utilizar las instrucciones de
sustracción DESARROLLO DE LA PRACTICA
• ;*******************************************************;
• ; Nombre : Complemento ;
• ; Proposito : calcula la diferencia entre dos variables ;
• ; Autor : XXXXX;
• ; FCreacion : 27/09/2010 ;
• ; FModificacion : ------ ;
• ;*******************************************************;
• LIST P=16f84A ; Modelo de PIC utilizado
• INCLUDE <P16f84A.INC> ; Contiene definiciones de elementos del PIC
• ;********DATOS
• num1 equ 0xA ; primer numero
• num2 equ 0xB ; segundo numero
• ;********CODIGO
• ORG 0 ; Indica donde comienza el programa
• Inicio
• movlw .20 ; W <- 20
• movwf num1 ; num1 <- 20
• movlw .10 ; W <- 10
• movwf num2 ; num2 <- 10
• comf num2,0 ; W <- ~num2
• addlw .1 ; W <- ~num2 + 1 = -num2
• addwf num1,W ; W <- num1 + ~num2 + 1 = num1 - num2
• movwf resul ; resul <- W
• END

27. DESARROLLO DE LA PRACTICA
• Escriba un programa que intercambie los valores almacenados en dos variables v1 v2, sin utilizar
variables auxiliares
• ;*****************************************************************;
• ; Nombre : Swap ;
• ; Proposito : Intercambia dos variables, sin utilizar variables auxiliares ;
• ; Autor : XXXXX XXXX;
• ; FCreacion : 27/09/20010;
• ; FModificacion : ------ ;
• ;*****************************************************************;
• LIST P=16f84A ; Modelo de PIC utilizado
• INCLUDE <P16f84A.INC> ; Contiene definiciones de elementos del PIC
• ;********DATOS
• v1 equ 0xA ; primer numero
• v2 equ 0xB ; segundo numero
• ;********CODIGO
• ORG 0 ; Indica donde comienza el programa
• Inicio
• movlw .7 ; W <- 10
• movwf v1 ; num1 <- 10
• movlw .5 ; W <- 15
• movwf v2 ; num2 <- 15
• xorwf v1, 1 ; v1 <- v1 .xor. v2
• xorwf v1, 0 ; W <- v1 .xor. v2
• xorwf v1, 1 ; v1 <- v1 .xor. v2
• movwf v2 ; v2 <- W
• END