Universidad Nacional de Ingeniería
Facultad de Electrotecnia y Computación
Departamento de Sistemas Digitales y Telecomunicaciones
2011
Guías de Laboratorios de
Máquinas Computadoras I
Luis Alberto Vargas Tijerino
Autor: Luis Alberto Vargas Tijerino Página 1
Contenido Laboratorio 1: Introducción a MPLAB y Proteus. .............................................................................................. 3
1.1 Objetivo. ................................................................................................................................................... 3
1.2 Introducción. ............................................................................................................................................ 3
1.3 MPLAB. ..................................................................................................................................................... 3
1.4 Procedimiento. ......................................................................................................................................... 3
1.4.1 Crear un Nuevo Proyecto. ................................................................................................................. 3
1.4.2 Configurar las herramientas del Lenguaje. ....................................................................................... 4
1.4.3 Crear una capeta para el Proyecto ................................................................................................... 5
1.4.4 Agregar Archivos existentes al Proyecto. ......................................................................................... 5
1.4.5 Agregar un nuevo Archivo al Proyecto ............................................................................................. 6
1.4.6 Compilar el proyecto ......................................................................................................................... 7
1.4.7 Crear el circuito en Proteus .............................................................................................................. 7
1.4.8 Cargar el Archivo fuente ................................................................................................................... 8
1.4.9 Realizar la simulación ........................................................................................................................ 9
1.4.10 Abrir la ventana de observación ..................................................................................................... 10
1.4.11 Agregar los Registros por Nombre .................................................................................................. 10
1.4.12 Agregar los Registros por Dirección ................................................................................................ 11
Laboratorio 2: Introducción al Lenguaje Ensamblador. .................................................................................. 13
2.1 Objetivo. ................................................................................................................................................. 13
2.2 Introducción. .......................................................................................................................................... 13
2.3 Instrucciones a utilizar. .......................................................................................................................... 13
2.4 Constantes Numéricas y Alfanuméricas ................................................................................................. 14
2.5 Procedimiento ........................................................................................................................................ 14
Laboratorio 3: Programación Elemental. ........................................................................................................ 17
3.1 Objetivo .................................................................................................................................................. 17
3.2 Introducción ........................................................................................................................................... 17
3.3 Instrucciones Aritméticas y Lógicas. ...................................................................................................... 17
3.4 Procedimiento ........................................................................................................................................ 18
3.5 Trabajo Extra Clase. ................................................................................................................................ 20
Laboratorio 4: Saltos Condicionales y Subrutinas de Retardo ........................................................................ 21
Autor: Luis Alberto Vargas Tijerino Página 2
4.1 Objetivo .................................................................................................................................................. 21
4.2 Introducción ........................................................................................................................................... 21
4.3 Subrutinas. ............................................................................................................................................. 21
4.4 Subrutinas Anidadas. .............................................................................................................................. 22
4.5 La Pila...................................................................................................................................................... 22
4.6 Ciclo Máquina ......................................................................................................................................... 23
4.7 Instrucciones a utilizar. .......................................................................................................................... 24
4.8 Procedimiento ........................................................................................................................................ 25
4.9 Trabajo Extra Clase. ................................................................................................................................ 27
Laboratorio 5: Tablas ....................................................................................................................................... 28
5.1 Objetivo .................................................................................................................................................. 28
5.2 Introducción ........................................................................................................................................... 28
5.3 Salto Indexado ........................................................................................................................................ 28
5.4 Tablas de datos en la memoria de Programa ........................................................................................ 28
5.5 Instrucciones a utilizar. .......................................................................................................................... 29
5.6 Procedimiento ........................................................................................................................................ 29
5.7 Trabajo Extra Clase. ................................................................................................................................ 30
Laboratorio 6: Macros ..................................................................................................................................... 32
6.1 Objetivo .................................................................................................................................................. 32
6.2 Introducción ........................................................................................................................................... 32
6.3 Macros .................................................................................................................................................... 32
6.4 Procedimiento ........................................................................................................................................ 33
6.5 Trabajo Extra clase ................................................................................................................................. 34
Autor: Luis Alberto Vargas Tijerino Página 3
Laboratorio 1: Introducción a MPLAB y Proteus.
1.1 Objetivo. Familiarizarse con el entorno de desarrollo MPLAB para crear nuevos proyectos.
1.2 Introducción. En este laboratorio el alumno aprenderá a crear nuevos proyectos utilizando el entorno de desarrollo MPLAB y
luego aprenderá a crear y simular los circuitos utilizando el simulador ISIS-Proteus.
1.3 MPLAB. MPLAB IDE es un software de “Entordo de desarrollo integrado” (Integrated Development Enviorement, IDE)
que se ejecuta bajo Windows. Con este entorno se pueden desarrollar aplicaciones para microcontroladores
en lenguajes Ensamblador y de alto Nivel (C y Basic).
MPLAB incluye:
Un editor de texto.
Un ensamblador llamado MPASM.
Un simulador llamado MPLAB SIM.
Un organizador de proyectos.
El programa es gratuito y puede ser descargado en la página del fabricante www.microchip.com [mic16f84,
p77]
1.4 Procedimiento.
1.4.1 Crear un Nuevo Proyecto.
1. Abrir el MPLAB-IDE
2. Dar clic en Project>Project wizard.
3. Dar clic en el Botón Siguiente del cuadro de Bienvenida.
4. Seleccionar en el cuadro desplegable el dispositivo PIC16F887 y luego presionar siguiente.
Autor: Luis Alberto Vargas Tijerino Página 4
1.4.2 Configurar las herramientas del Lenguaje.
1. Seleccionar " MPASM Assambler" de la lista Active Toolsuite.
2. En el cuadro de Texto “Location” escribir C:\ Archivos de Programa \Microchip\MPASM
Suite\mpasmwin.exe o buscarlo mediante el botón browse.
3. Seleccionar “MPLINK Object Linker” de la lista Active Toolsuite.
4. En el cuadro de Texto “Location” escribir C:\ Archivos de Programa \Microchip\MPASM
Suite\mplink.exe o buscarlo mediante el botón browse.
5. Seleccionar “MPLIB Librarian” del cuadro de lista Active Toolsuite.
6. En el cuadro de Texto “Location” escribir C:\Archivos de Programa\Microchip\MPASM Suite\mplib.exe
o buscarlo mediante el botón browse.
7. Finalmente presionar Siguiente.
Autor: Luis Alberto Vargas Tijerino Página 5
1.4.3 Crear una capeta para el Proyecto
1. En el cuadro de Texto “Create New Project” escribir C:\laboratorios\lab1.
2. Presionar el botón Next.
3. Presionar ok en el cuadro de dialogo que aparecerá.
1.4.4 Agregar Archivos existentes al Proyecto.
1. Agregar el archivo C:\Archivos de Programa\Microchip\MPASM Suite\Template\Code\
18F887TEMP.ASM. Este es un archivo de ejemplo que puede ser utilizado para iniciar cualquier
proyecto, este contiene las secciones esenciales para cualquier archivo fuente y también contiene
información que ayudará para escribir y organizar el código.
2. Presionar el Botón Add.
3. Dar clic en la letra A hasta que aparezca una C.
4. Presionar Siguiente.
5. Presionar Finalizar.
Autor: Luis Alberto Vargas Tijerino Página 6
1.4.5 Agregar un nuevo Archivo al Proyecto
1. Presionar el menú View>Project para ver la ventana de proyectos
2. En la ventana de proyectos dar clic derecho en lab1.mcp y seleccionar Add New File
3. Nombrar el archivo como Inst_Bas.asm
4. Copiar el Código 1.1 Inst_Bas.asm
Código 1.1 Inst_Bas.asm
list p=16f887 ; list directive to define processor
#include <p16f887.inc> ; processor specific variable definitions
__CONFIG _CONFIG1, _LVP_OFF & _FCMEN_ON & _IESO_OFF & _BOR_OFF & _CPD_OFF &
_CP_OFF & _MCLRE_ON & _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT
__CONFIG _CONFIG2, _WRT_OFF & _BOR21V
ORG 0x000 ; Vector de Reset del procesador
main
BANKSEL ANSEL ;Seleccionamos el Banco al que pertenece ANSEL (Banco 3)
CLRF ANSEL ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH
CLRF ANSELH ;para configurar todos los pines como digitales
BANKSEL TRISB ;Seleccionamos el Banco al que pertenece TRISB (Banco 1)
MOVLW B'11111111' ;Movemos el literal B'11111111' al registro de trabajo
MOVWF TRISB ;Movemos el dato del registro de trabajo al registro TRISB
;Para configurar todos los pines de PORTB como entrada
CLRF TRISD ;Ponemos a 0 todos los bit de TRISD para configurar como
;salida todos los pines de PORTD
BANKSEL PORTB ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)
bucle
MOVF PORTB,W ;Movemos el dato del registro PORTB al registro de trabajo
MOVWF PORTD ;Movemos el dato del registro de trabajo al registro PORTD
GOTO bucle ;Salta hacia la siguiente linea despues de la etiqueta bucle.
Autor: Luis Alberto Vargas Tijerino Página 7
END ;Fin del Programa
1.4.6 Compilar el proyecto
1. Presionar el menú Project>Build All o presionar la combinación de teclas ctrl+F10 para compilar el
código.
2. En el cuadro de dialogo que aparecerá presionar el botón Absolute.
1.4.7 Crear el circuito en Proteus
1. Abrir el simulador ISIS-Proteus .
2. Presionar la tecla “P” del teclado.
3. Escribir PIC16F887 en la caja de búsqueda (ver Figura 1.1) y darle doble clic al dispositivo en la lista de
resultados para que aparezca en la ventana de dispositivos seleccionados.
Figura 1.1. Ventana Pick Devices
Ventana de
dispositivos
seleccionados
Lista de
Resultados
Caja de
Busqueda
Autor: Luis Alberto Vargas Tijerino Página 8
4. Escribir LOGICPROBE en la caja de búsqueda y darle doble clic al dispositivo en la lista de resultados
para que aparezca en la ventana de dispositivos seleccionados.
5. Escribir LOGICSTATE en la caja de búsqueda y darle doble clic al dispositivo en la lista de resultados
para que aparezca en la ventana de dispositivos seleccionados.
6. Cerrar la ventana de Pick Devices.
7. En la ventana de dispositivos seleccionados darle un clic al dispositivo y luego dar un clic en la ventana
de trabajo para que aparezca el dispositivo y finalmente ubicar los dispositivos como aparece en la
siguiente figura.
a. Si se desea rotar el dispositivo en sentido horario se debe presionar la tecla “+” del teclado
numérico.
b. Si se desea rotar el dispositivo en sentido anti-horario presionar la tecla “-“ del teclado
numérico.
c. Si se desea rotar el dispositivo en espejo se debe presionar la combinación de teclas “ctrl+m”.
8. Para conectar cada Pin debes ubicar el cursor sobre el extremo del pin del primer dispositivo (debe
aparecer un lápiz), luego dar clic, ubicarse en el extremo del otro pin y dar clic.
9. Conectar el Pin del LOGICPROBE con el pin RB0 del PIC16F887.
10. Guardar el esquema (menú Archivo>Save Design) en la misma carpeta del Proyecto.
1.4.8 Cargar el Archivo fuente
1. Darle doble clic al PIC16F887 ubicado en la ventana de trabajo
2. Darle clic al botón de la caja de texto Program File y seleccionar el archivo fuente Inst_Bas.cof
3. Cambiar la frecuencia de reloj a 8MHz.
Ventana de
dispositivos
seleccionados
Ventana de
Trabajo.
PIC16F887
LOGICPROBE
Barra de
Simulación LOGICSTATE
Autor: Luis Alberto Vargas Tijerino Página 9
4. Luego presionar el botón Ok.
1.4.9 Realizar la simulación
1. Dar clic en el botón Play de la barra de simulación y observar la
simulación.
2. Dar clic en el botón stop de la barra de simulación.
3. Dar clic en el botón step de la barra de simulación para iniciar la simulación paso a paso o
presionar la combinación de teclas Ctrl+F12.
4. A continuación se mostraran la ventana del código fuente y la ventana de variables.
Ventana de
Código
Fuente
Ventana de
Variables
Autor: Luis Alberto Vargas Tijerino Página 10
5. En la ventana de Código aparecen 4 botones .
a. Step over o tecla F10: La simulación se realiza paso a paso pero al encontrar la llamada a
una función el depurador la realiza toda la función de una sola vez sin entrar a ella.
b. Step into o tecla F11: La simulación se realiza paso a paso y al encontrar la llamada a una
función el depurador la realiza entra a la función realizándola paso a paso.
c. Step out o combinación Ctrl+F11: Si el depurador se encuentra en el código interno de una
función al presionar este botón saldrá del código interno de la función y se mostrará la línea
siguiente a la llamada a la función.
d. Run to Source Line o combinación Ctrl+F10: Ubica al depurador en la línea seleccionada por
el usuario.
Una vez que se presione uno de los botones anteriores se puede observar el cambio en la ventana de código y
en la ventana de variables.
1.4.10 Abrir la ventana de observación
1. Dar clic en menú debug>watch window.
1.4.11 Agregar los Registros por Nombre
1. Dar clic derecho en la ventana de observación y seleccionar Add Items (By Name)
Autor: Luis Alberto Vargas Tijerino Página 11
2. Luego dar doble clic a los registros TRISB y PORTB en la ventana Add Memory Item.
1.4.12 Agregar los Registros por Dirección
1. Dar clic derecho en la ventana de observación y seleccionar Add Items (By Addres)
Autor: Luis Alberto Vargas Tijerino Página 12
2. En la ventana Add Memory Iten escribir en el cuadro de Texto Name PORTD y en el cuadro de Texto
Address escribir la dirección 0x0008.
3. Presionar el botón Add y para finalizar presionar el botón Done
Autor: Luis Alberto Vargas Tijerino Página 13
Laboratorio 2: Introducción al Lenguaje Ensamblador.
2.1 Objetivo. Familiarizarse con las instrucciones básicas mediante la implementación del ejemplo práctico.
2.2 Introducción. El lenguaje máquina es difícil de utilizar por el hombre ya que se aleja de su forma natural de expresarse, por
esto se utiliza el lenguaje ensamblador, que es la forma de expresar las instrucciones de forma más natural al
hombre y a su vez es el más cercano al microcontrolador porque cada una de sus instrucciones corresponde a
un código máquina.
Un dominio adecuado de las instrucciones del lenguaje ensamblador permite alcanzar un nivel elevado de
aprovechamiento de las prestaciones hardware del microcontrolador. En esta guía de laboratorio
estudiaremos las instrucciones básicas para desarrollar cualquier programa utilizando lenguaje Ensamblador y
también aprenderemos a configurar las líneas de los puertos.
2.3 Instrucciones a utilizar. El lenguaje ensamblador utiliza nemónicos que son grupos de caracteres alfanuméricos que simbolizan las
órdenes o tareas a realizar con cada instrucción. Los nemónicos se corresponden con las iniciales del nombre
de la instrucción en inglés, de forma que “recuerdan” la operación que realiza la instrucción. [mic16f84, pag.
58]
Por ejemplo: ADDLW d’58’ es igual a “11111000111010”
La Tabla 2.1 muestra una lista de instrucciones que utilizaremos en este laboratorio. Estas instrucciones serán
utilizadas en el Código 2.1 Inst_Bas.asm
Tabla 2.1
Nemónico Significado Descripción Flags afectados
ORG k Indica la dirección k en la que se iniciará el código siguiente. BANKSEL f Bank Select f Selecciona el Banco al que pertenece el registro f RPx CLRW Clear w El contenido del registro w se borra asignándole b’0000_0000’. Z CLRF f Clear f Borra el contenido del registro fuente asignándole
b’0000_0000’. Z
MOLW k Move w Mueve el valor de la constante k al registro w. MOVF f,d Move f Si d=0 ó d=w mueve el valor del registro f a w.
Si d=1 ó d=f mueve el valor del registro f al mismo registro f. Z
MOVWF f Move w to f Mueve el valor del registro w al registro f MOVFW f Move f to w Mueve el valor del registro f al registro w BCF f,b Bit Clear f Pone a cero el bit b del registro f BSF f,b Bit Set f Pone a uno el bit b del registro f GOTO k Go To k Salta hacia la dirección especificada por k, el cual puede ser una
Autor: Luis Alberto Vargas Tijerino Página 14
etiqueta o una constante. END End of Program Indica el final de los programas, es decir, no se puede escribir
código después de esta instrucción
2.4 Constantes Numéricas y Alfanuméricas El ensamblador MPASM soporta los sistemas de numeración decimal, hexadecimal, octal, binario y el código
alfanumérico ASCII. La representa la forma de especificar el sistema de numeración o códigos alfanuméricos.
Tabla 2.2
Tipo Sintaxis Ejemplo
Decimal D’<cantidad>’ d’<cantidad>’ .<cantidad>
MOVLW D‟109‟
MOVLW d‟109‟
MOVLW .109
Hexadecimal H’<cantidad>’ h’<cantidad>’ 0x<cantidad> <cantidad>H <cantidad>h
MOVLW H‟6D‟
MOVLW h‟6D‟
MOVLW 0x6D
MOVLW 6DH
MOVLW 6Dh
Octal O’<cantidad>’ o’<cantidad>’
MOVLW O‟155‟
MOVLW o‟155‟
Binario B’<cantidad>’ b’<cantidad>’
MOVLW B‟01101101‟
MOVLW b‟01101101‟
ASCII A’<carácter>’ a’<carácter>’ ‘<carácter>’
MOVLW A‟M‟
MOVLW a‟M‟
MOVLW „M‟
“String” o Cadena “<string>” DT “Hola”
2.5 Procedimiento 1. Crear un Nuevo Proyecto.
2. Crear una capeta para el Proyecto llamada Lab2
3. Agregar un nuevo Archivo al Proyecto.
4. Copiar el Código 2.1 Inst_Bas.asm
Código 2.1 Inst_Bas.asm
list p=16f887 ; list directive to define processor
#include <p16f887.inc> ; processor specific variable definitions
__CONFIG _CONFIG1, _LVP_OFF & _FCMEN_ON & _IESO_OFF & _BOR_OFF & _CPD_OFF &
_CP_OFF & _MCLRE_ON & _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT
__CONFIG _CONFIG2, _WRT_OFF & _BOR21V
ORG 0x000 ; Vector de Reset del procesador
main
BANKSEL ANSEL ;Seleccionamos el Banco al que pertenece ANSEL (Banco 3)
Autor: Luis Alberto Vargas Tijerino Página 15
;BSF STATUS,RP1 ;Ponemos a uno el bit RP1 del registro STATUS
;BSF STATUS,RP0 ;Ponemos a uno el bit RP0 del registro STATUS
CLRF ANSEL ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH
CLRF ANSELH ;para configurar todos los pines como digitales
BANKSEL TRISB ;Seleccionamos el Banco al que pertenece TRISB (Banco 1)
;BCF STATUS,RP0 ;Ponemos a cero el bit RP0 del registro STATUS
MOVLW B'11111111' ;Movemos el literal B'11111111' al registro de trabajo
MOVLW .255 ;Movemos el literal .255 al registro de trabajo
MOVLW 0XFF ;Movemos el literal 0XFF al registro de trabajo
MOVLW O'177' ;Movemos el literal O'177' al registro de trabajo
MOVWF TRISB ;Movemos el dato del registro de trabajo al registro TRISB
;Para configurar todos los pines de PORTB como entrada
CLRF TRISD ;Ponemos a 0 todos los bit de TRISD para configurar como
;salida todos los pines de PORTD
BANKSEL PORTB ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)
;BCF STATUS,RP0 ;Ponemos a cero el bit RP0 del registro STATUS
bucle
MOVF PORTB,W ;Movemos el dato del registro PORTB al registro de trabajo
;MOVFW PORTB
MOVWF PORTD ;Movemos el dato del registro de trabajo al registro PORTD
GOTO bucle ;Salta hacia la siguiente linea despues de etiqueta bucle.
;GOTO $-2 ;Salta 2 pocisiones hacia atras.
END ;Fin del Programa
5. Compilar el proyecto
6. Crear el circuito en Proteus. Para ello será necesario buscar mediante la caja de búsqueda en la
ventana PICK DEVICE el PIC16F887, el LOGICSTATE y el LOGICPROBE.
7. Cargar el Archivo fuente, Realizar la simulación (CTRL+F12 para iniciar y F10 para ir paso a paso), Abrir
la ventana de observación y Agregar los Registros por Nombre ANSEL, ANSELH, PORTB, PORTD, TRISB
y TRISD.
8. Contestar las Siguientes Preguntas:
PIC16F887
LOGICPROBE
LOGICSTATE
Autor: Luis Alberto Vargas Tijerino Página 16
a. ¿Cuál es el valor de RPx después de las líneas 10, 15 y 25?
b. ¿Cuál es el valor de los registros ANSEL y ANSELH después de la líena 15?
c. ¿Cuál es el valor del registro W después de la línea 17, 18 y 19?
d. ¿Cuál es el valor del registro TRISB después de la línea 21?
e. ¿Cuál es el valor del registro TRISD después de la línea 23?
f. ¿Cuál es el valor del registro PORTB después de la línea 28?
g. ¿Cuál es el valor del registro W después de la línea 28?
h. ¿Cuál es el valor del registro PORTD después de la línea 30?
i. ¿Qué ocurre después de la línea 31?
j. Cambiar el valor de los LOGICSTATE y contestar de nuevo las preguntas f a la g.
9. Comentar las líneas 10, 15, 25 y 32 y descomentar las líneas 11, 12, 16, 26 y 32.
10. Compilar el proyecto y Realizar la simulación de nuevo.
a. ¿Cuál es el valor de RPx después de las líneas 11, 12, 16 y 26?
b. ¿Qué ocurre después de la línea 31?
Autor: Luis Alberto Vargas Tijerino Página 17
Laboratorio 3: Programación Elemental.
3.1 Objetivo Familiarizarse con las instrucciones aritméticas y lógicas del lenguaje ensamblador.
3.2 Introducción En este laboratorio realizaremos los primeros programas elementales utilizando las instrucciones aritméticas y
lógicas.
3.3 Instrucciones Aritméticas y Lógicas. Los PIC de la gama media y baja pueden realizar las siguientes operaciones
Aritméticas: sumar, restar, incrementar y decrementar un registro.
Lógicas: AND, OR, XOR, NOT (o complemento), rotación de bits y el intercambio de nibbles.
Nemónico Significado Descripción Operación Flags afectados
ADDLW k Add k to W Suma el contenido del registro w con el valor del literal k.
(w)=(w)+k Z, C, DC
ADDWF f,d Add w and f Suma el registro w con el registro f.
Si d=0 ó d=w el resultado se almacena en w.
Si d=1 ó d=f el resultado se almacena en f.
(d)=(w)+(f) Z, C, DC
SUBLW k Subtract k to W Resta el registro w menos el literal k. (w)=(w)-k Z, C SUBWF f,d Subtract w and f Suma el registro w con el registro f.
Si d=w el resultado se almacena en w.
Si d=f el resultado se almacena en f.
(d)=(w)-(f) Z, C
DECF f,d Decrement f Decrementa el valor de f en uno
Si d=w el resultado se almacena en w.
Si d=f el resultado se almacena en f.
(d)=(f)-1 Z, C
INCF f,d Increment f Incrementa el valor de f en uno
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)=(f)+1 Z, C, DC
ANDLW k AND k with w Efectúa la operación AND entre w y k (w)=(w) and k Z ANDWF f,d AND w with f Efectúa la operación AND entre w y f
Si d=0 o d=w el resultado se almacena en w.
(d)=(w) and (f) Z
Autor: Luis Alberto Vargas Tijerino Página 18
Si d=1 o d=f el resultado se almacena en f.
IORLW k OR k with w Efectúa la operación OR entre w y k (w)=(w) or k Z IORWF f,d OR w with f Efectúa la operación OR entre w y f
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)=(w) or (f) Z
XORLW k XOR k with w Efectúa la operación XOR entre w y k (w)=(w) xor k Z XORWF f,d XOR w with f Efectúa la operación XOR entre w y f
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)=(w) xor (f) Z
COMF f,d NOT f Efectúa la operación NOT entre de f
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)=not (f) Z
RLF f,d Shift Left f Desplaza un bit hacia la izquierda a f
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)= (f)<<1 C
RRF f,d Shift Right f Desplaza un bit hacia la derecha a f
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)= (f)>>1 C
SWAPF f,d Swap Nibbles f Intercambia los Nibbles de f
Si d=0 o d=w el resultado se almacena en w.
Si d=1 o d=f el resultado se almacena en f.
(d)= swap(f) Z
Como se aprecia en la tabla anterior, los PIC10, PIC12 y PIC16 no poseen instrucciones de multiplicación y
división, para realizar estas operaciones es necesario sumar o restar el número de veces necesario.
Por ejemplo, si se desea realizar una multiplicación de un número por 5 este deberá ser sumado 5 veces.
5 a a a a a a
3.4 Procedimiento 1. Crear un Nuevo Proyecto.
Autor: Luis Alberto Vargas Tijerino Página 19
2. Crear una capeta para el Proyecto llamada Lab2
3. Agregar un nuevo Archivo al Proyecto.
4. Copiar el Código 3.1 Inst_ari_log
Código 3.1 Inst_ari_log
list p=16f887 ; list directive to define processor
#include <p16f887.inc> ; processor specific variable definitions
__CONFIG _CONFIG1, _LVP_OFF & _FCMEN_ON & _IESO_OFF & _BOR_OFF & _CPD_OFF &
_CP_OFF & _MCLRE_ON & _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT
__CONFIG _CONFIG2, _WRT_OFF & _BOR21V
VAR1 EQU 0X20
VAR2 EQU 0X21
VAR3 EQU 0X23
ORG 0x000 ; Vector de Reset del procesador
main
BANKSEL VAR1 ;Seleccionamos el Banco al que pertenece VAR1
CLRF VAR1 ;VAR1 = 0
CLRF VAR2 ;VAR2 = 0
CLRF VAR3 ;VAR3 = 0
MOVLW 23 ;W = 0x23
ADDLW 45 ;W = W + 0x45
ADDWF VAR1,W ;W = VAR1 + W
SUBLW 51 ;W = 51 - W
SUBWF VAR1,F ;VAR1 = VAR1-W
INCF VAR1,F ;VAR1 = VAR1 + 1
DECF VAR2,W ;W = VAR2 - 1
ANDLW 0X0F ;W =W and 0x0F (Ponemos el Nibble Alto de W en bajo)
ANDWF VAR2,F ;VAR2=VAR2 and W
IORLW 0XF0 ;W = W or 0XF0 (Ponemos el Nible Alto de W en alto)
IORWF VAR3,F ;VAR3 = W or VAR3
XORLW B'01010101' ;W = W xor B'01010101'
XORWF VAR3,F ;VAR3 = VAR3 xor W
RLF VAR1,F ;Desplazamos un bit a la izquierda VAR1
RRF VAR1,F ;Desplazamos un bit a la derecha VAR2
SWAPF VAR1,F ;Intercambiamos los Nibbles
;VAR1=VAR1+33
MOVLW .33
ADDWF VAR1,F
;VAR2=VAR1+0X55
MOVLW 0X55
ADDWF VAR1,W
MOVWF VAR2
;VAR3=VAR1+VAR2
MOVFW VAR1
ADDWF VAR2,W
MOVWF VAR3
;VAR1=VAR1 x 2
BCF STATUS,C
RLF VAR1
;VAR1=VAR1 / 2
BCF STATUS,C
RRF VAR1,F
;VAR1=VAR1 x 16
MOVLW 0x0F
Autor: Luis Alberto Vargas Tijerino Página 20
ANDWF VAR1,F
SWAPF VAR1,F
GOTO main
END ;Fin del Programa
5. Compilar el proyecto
6. Crear el circuito en Proteus. Para ello será necesario buscar mediante la caja de búsqueda en la
ventana PICK DEVICE el PIC16F887.
7. Cargar el Archivo fuente, Realizar la simulación (CTRL+F12 para iniciar y F10 para ir paso a paso), Abrir
la ventana de observación y Agregar los Registros por Dirección VAR1, VAR2 y VAR3 con las
direcciones 0x20, 0x21 y 0x23 respectivamente.
8. Realizar una tabla con los valores de los registros W, VAR1, VAR2 y VAR3 en cada una de las líneas de
código.
9. ¿Qué ocurre cuando el resultado de una suma o una multiplicación es mayor a 255?
10. ¿Qué ocurre cuando el resultado de una resta o una división es menor a 0?
3.5 Trabajo Extra Clase. 1. Contestar las siguientes preguntas:
a. ¿Cuál es el algoritmo (Pseudocódigo o Diagrama de Flujo) para realizar operaciones de
multiplicación y división con los PIC10, PIC12 y PIC16 en lenguaje ensamblador?
b. ¿Cuál es el algoritmo (Pseudocódigo o Diagrama de Flujo) para realizar operaciones de suma,
resta multiplicación y división con variables de 16 bits?
c. ¿Cómo funciona el módulo de multiplicación integrado que poseen los PIC18 en adelante?
d. ¿Qué otras operaciones aritméticas pueden realizar los dsPIC?
e. ¿Cuáles son las ventajas de que la ALU del MCU manipule más bits?
2. Elaborar un programa en lenguaje ensamblador que realice las siguientes operaciones:
a. PORTC = PORTA + Valor de los tres últimos Números de tu carné.
b. PORTD = PORTB – PORTA
c. Almacenar el Nibbles altos de PORTB en VAR1, es decir, VAR1 = PORTD and 0x0F
Autor: Luis Alberto Vargas Tijerino Página 21
Laboratorio 4: Saltos Condicionales y Subrutinas de Retardo
4.1 Objetivo Aprender a elaborar subrutinas de retardo en los PIC
4.2 Introducción Los programas no suelen ejecutar las instrucciones de una manera lineal una tras otras. Por lo general es
necesario romper esta secuencia en puntos determinados debido a una toma de decisión o por cualquier otro
motivo.
Otra característica importante de los programas es que tienden a diseñarse de una forma modular o
estructurada, es decir, cada programa posee un conjunto de instrucciones que realizan una tarea específica y
que se repite un gran número de veces. Por ejemplo, en la mayoría de proyectos es necesario controlar el
tiempo que tardan en ejecutarse algunas acciones.
Además, es sumamente importante que las tareas se realicen en tiempos determinados por el diseñador, para
ello es necesario utilizar pausas o retardos, de lo contrario la ejecución del programa sería demasiado rápida y
controlar ciertos dispositivos sería imposible. En este laboratorio aprenderemos a utilizar las subrutinas de
Retardo y la manera de elaborarlas. [mic16f84, p119]
4.3 Subrutinas. Una subrutina es un conjunto de instrucciones al que se tiene acceso desde cualquier punto del programa
principal. Es decir, una subrutina es un subprograma que se ejecuta cada vez que el programa principal lo
necesita.
La Figura 4.1 ilustra el procedimiento de ejecución del programa con subrutinas. Las instrucciones del
programa principal son ejecutadas sucesivamente hasta que se encuentra la primera instrucción call ProcesoX,
después de lo cual, la subrutina ProcesoX se ejecuta como cualquier otra sección del programa. La última
instrucción de la subrutina es return que causa el regreso de la secuencia de ejecución al programa principal.
Figura 4.1 Utilización de las Subrutinas
Autor: Luis Alberto Vargas Tijerino Página 22
La principal ventaja de las subrutinas es que la extensión de los programas se hace mucho más corta, tal como
se aprecia en la Figura 4.1. No obstante, las subrutinas presentan la desventaja que su uso provoca una
ejecución más lenta debido que se tienen que ejecutar dos instrucciones extras call y return.
4.4 Subrutinas Anidadas. Cuando una subrutina llama a otra subrutina se produce la situación conocida como anidamiento de
subrutinas. Cada call sucesivo sin que intervenga un return crea un nivel de anidamiento adicional. Esto se
ilustra en la Figura 4.2.
Figura 4.2 Subrutinas Anidadas
El nivel de anidamiento está limitado para cada microcontrolador y en el PIC16F887 es de 32 niveles. Es decir,
no pueden haber más de 32 subrutinas anidadas.
4.5 La Pila La pila (stack en inglés) es una zona de memoria que se encuentra separada tanto de la memoria de programa
como de la de datos dentro del microcontrolador. Su estructura es del tipo LIFO (Last In First Out) por lo que el
último dato que se guarda es el primero que sale.
Autor: Luis Alberto Vargas Tijerino Página 23
Figura 4.3 Estructura de la pila y memoria de programa del PIC16F887.
El PIC16F887 dispone de una pila con 32 niveles o registros de una longitud de 13 bits cada uno de ellos
(Figura 4.3).
La manera de cargar la pila es a través de la llamada a subrutina con la instrucción call, que almacena el
contenido del contador de programa (PC) en la posición superior de la pila. Para recuperar el contenido de la
pila en el PC, hay que ejecutar la instrucción de retorno de subrutina.
4.6 Ciclo Máquina El tiempo que tarda en ejecutarse un programa depende de la frecuencia del oscilador conectado al
microcontrolador y el número de ciclos máquinas ejecutados. Un ciclo máquina es la unidad básica de tiempo
que utiliza el microcontrolador. Para los PIC10, PIC12, PIC16 y PIC18 el ciclo máquina equivale a 4 ciclos de
reloj, por lo tanto, el tiempo que tarda en producirse un ciclo máquina es igual a cuatro veces el período del
oscilador. (Figura 4.4)
Autor: Luis Alberto Vargas Tijerino Página 24
Figura 4.4 Ciclo máquina
Las instrucciones en el microcontrolador necesitan 1 ciclo máquina para ejecutarse, excepto las de salto (goto,
call, btfss, btfsc, return, etc) que necesitan dos ciclos máquina.
El tiempo que tarda el microcontrolador en ejecutar una tare viene fijado por la fórmula siguiente:
Siendo:
f la frecuencia del oscilador.
cm, el número de ciclos máquina que tarda en ejecutar la tarea.
4.7 Instrucciones a utilizar. En la tabla siguiente se muestran estas instrucciones.
Nemónico Significado Descripción
BTFSC f,b Bit Test f, Skip if Clear Ignora y salta la instrucción que sigue a esta si el bit b es cero. BTFSS f,b Bit Test f, Skip if Set Ignora y salta la instrucción que sigue a esta si el bit b es uno. DECFSZ f,d Decrement f, Skip if
Zero Decrementa en uno el contenido del registro f, ignora y salta la instrucción siguiente si el resultado es Cero.
Si d=w el resultado se almacena en w.
Si d=f el resultado se almacena en f. INCFSZ f,d Increment f, Skip if
Zero Incrementa en uno el contenido del registro f, ignora y salta la instrucción siguiente si el resultado es Cero.
Si d=w el resultado se almacena en w.
Si d=f el resultado se almacena en f. NOP No Operation No realiza operación alguna. Se utiliza para consumir un ciclo
máquina sin hacer nada. CALL k Call address k Provoca que la ejecución del programa se transfiera a la
subrutina. RETURN Return Provoca el retorno a la dirección que sigue al CALL que realizó la
última llamada. CBLOCK k Constant Block Define un bloque de variables que se almacenaran en la
memoria RAM comenzando desde la dirección k ENDC End Constant Block Indica el fin del bloque de variables
Autor: Luis Alberto Vargas Tijerino Página 25
4.8 Procedimiento 1. Crear un Nuevo Proyecto.
2. Crear una capeta para el Proyecto llamada Lab2
3. Agregar un nuevo Archivo al Proyecto.
4. Copiar el Código 4.1 Led_blink
Código 4.1 Led_blink
list p=16f887 ; list directive to define processor
#include <p16f887.inc> ; processor specific variable definitions
__CONFIG _CONFIG1, _LVP_OFF & _FCMEN_ON & _IESO_OFF & _BOR_OFF & _CPD_OFF &
_CP_OFF & _MCLRE_ON & _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT
__CONFIG _CONFIG2, _WRT_OFF & _BOR21V
CBLOCK 0X20 ;Inicio del bloque de variables en la direccion 0x20
VAR1 ;VAR1 se declara en la direccion 0x20
VAR2 ;VAR2 se declara en la direccion 0x21
VAR3 ;VAR3 se declara en la direccion 0x22
ENDC
ORG 0x000 ; Vector de Reset del procesador
main
BANKSEL TRISD ;Seleccionamos el Banco al que pertenece TRISB (Banco 1)
CLRF TRISD ;Ponemos a 0 todos los bit de TRISD para configurar como
;salida todos los pines de PORTD
BANKSEL PORTD ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)
bucle
MOVLW .5 ;Mover al registro W el valor 5 decimal
CALL Retardo_us ;Llamar a la rutina Retardo_us (tardara 4 + 4x5=24 ciclos)
movlw .250 ;Mover al registro W el valor 250 decimal
CALL Retardo_ms ;Llamar a la rutina Retardo_ms (tardara 4 + 2003 x 250 ciclos)
BTFSS PORTD,0 ;Probar si el bit 0 de PORTD es 1
GOTO Led_on ;si es 0 saltar a Led_ond
Led_of
BCF PORTD,0 ;Poner a 0 el bit 0 de PORTD (Apagar LED)
GOTO bucle ;Saltar a bucle
Led_on
BSF PORTD,0 ;Poner a 1 el bit 0 del PORTD (Encender Led)
GOTO bucle ;Saltar a bucle
;***************************************************************************************
;Libreria de Retardos
;***************************************************************************************
CBLOCK
R_Cont1 ;R_cont1 se declara en la direccion 0x23
R_Cont2 ;R_cont2 se declara en la direccion 0x24
ENDC
;El proximo Bloque "Retardo_ms" tarda:
;5+2003M ciclos maquinas
Retardo_ms ;2
movwf R_Cont2 ;1
movlw .249 ;1
Ciclo_ms
call Retardo_us ;1000M
Autor: Luis Alberto Vargas Tijerino Página 26
call Retardo_us ;1000M
decfsz R_Cont2,F ;M+1
goto Ciclo_ms ;2M-2
return ;2
;El proximo Bloque "Retardo_us" tarda:
;4+4k ciclos maquinas
Retardo_us ;2
movwf R_Cont1 ;1
Ciclo_us
nop ;k
decfsz R_Cont1,F ;k+1
goto Ciclo_us ;2k-2
return ;2
END
5. Compilar el proyecto
6. Crear el circuito en Proteus. Para ello será necesario buscar mediante la caja de búsqueda en la
ventana PICK DEVICE el PIC16F887 y LOGICPROBE.
7. Cargar el Archivo fuente, cambiar frecuencia de reloj a 8MHz, Realizar la simulación (CTRL+F12 para
iniciar y F10 para ir paso a paso), Abrir la ventana de observación y Agregar los Registros por
Dirección R_cont1, R_cont2 y R_cont3 con las direcciones 0x23 y 0x24 respectivamente.
8. ¿Qué ocurre en la línea 22 sí se presiona F10 o F11?
9. ¿Cuánto tiempo tarda y cuantos ciclos se utilizan para realizar la línea 22? Explique por qué.
10. ¿Cuánto tiempo tarda y cuantos ciclos se utilizan para realizar la línea 24? Explique por qué.
11. Cambie la frecuencia de reloj a 8MHz y conteste de nuevo las preguntas 9 y 10.
12. Explique qué ocurre en la línea 25.
PIC16F887
LOGICPROBE
Autor: Luis Alberto Vargas Tijerino Página 27
4.9 Trabajo Extra Clase. 1. Conteste las siguientes preguntas:
a. ¿A qué equivale una subrutina en los lenguajes de alto nivel (C y BASIC)?
b. ¿Cuantos ciclos se necesitan para un retardo de 3 segundos si el PIC tiene un cristal de 20MHz?
2. Elaborar un programa en lenguaje ensamblador que realice lo siguiente:
a. Si el dato ingresado a PORTB es 0 que RD0 sea 1.
b. Si el dato ingresado a PORTB es igual a 123 que RD1 sea 1.
c. Si el dato ingresado a PORTB es mayor a 123 que RD2 sea 1.
d. Si el dato ingresado a PORTB es menor a 123 que RD3 sea 1.
e. Si el dato ingresado a PORTB es igual al dato ingresado a PORTC que RD4 sea 1.
f. Si el dato ingresado a PORTB es mayor al dato ingresado a PORTC que RD5 sea 1.
g. Si el dato ingresado a PORTB es menor al dato ingresado a PORTC que RD6 sea 1.
h. Si RA0 es 1 entonces que se realice un led_blink en RA1 cada 2 segundos.
Autor: Luis Alberto Vargas Tijerino Página 28
Laboratorio 5: Tablas
5.1 Objetivo Comprender como almacenan y manipulan los valores constantes los PIC10, PIC12 y PIC16 mediante la
implementación de Tablas.
5.2 Introducción En la mayoría de proyectos es necesario utilizar una gran cantidad de datos almacenados en tablas o arreglos
de constantes. Este laboratorio trata de su manejo para los PIC de la gama media y baja aplicándolas en el
manejo de un display de 7 segmentos.
5.3 Salto Indexado El salto indexado es una técnica que permite resolver problemas que puedan ser representados mediante una
tabla de verdad. En los PIC10, 12 y 16 se basa en la utilización de la instrucción ADDWF PCL,F, de este modo, la
dirección del salto se consigue sumando al contador de programa (PCL) un valor de desplazamiento
almacenado en el registro de trabajo W.
5.4 Tablas de datos en la memoria de Programa Una tabla de datos en la memoria ROM de programa es una lista de constantes que el programa puede
recoger mediante la instrucción retlw.
Una de las mayores aplicaciones del manejo de la tabla de datos, es la resolución de tablas de verdad grabadas
en ROM. El Código 5.1 muestra la subrutina que contiene la tabla de verdad formada por una serie de datos
ordenados secuencialmente para convertir un código binario a su equivalente en display de 7 segmentos.
Código 5.1 Subrutina Binario_7Segmentos
; Subrutina "Binario_7Segmentos" --------------------------------------------------------
;
Binario_a_7Segmentos ; Tabla para display de 7 segmentos.
addwf PCL,F
Tabla retlw 3Fh ; El código 7 segmentos para el "0".
retlw 06h ; El código 7 segmentos para el "1".
retlw 5Bh ; El código 7 segmentos para el "2".
retlw 4Fh ; El código 7 segmentos para el "3".
retlw 66h ; El código 7 segmentos para el "4".
retlw 6Dh ; El código 7 segmentos para el "5".
retlw 7Dh ; El código 7 segmentos para el "6".
retlw 07h ; El código 7 segmentos para el "7".
retlw 7Fh ; El código 7 segmentos para el "8".
retlw 67h ; El código 7 segmentos para el "9".
retlw 77h ; El código 7 segmentos para la "A".
retlw 7Ch ; El código 7 segmentos para la "B".
retlw 39h ; El código 7 segmentos para la "C".
retlw 5Eh ; El código 7 segmentos para la "D".
retlw 79h ; El código 7 segmentos para la "E".
retlw 71h ; El código 7 segmentos para la "F".
Autor: Luis Alberto Vargas Tijerino Página 29
Los valores de las constantes están grabados y no se pueden alterar. La única manera de alterar una tabla
ROM es volver a grabar el PIC.
Las tablas en ROM difieren de las tablas en la memoria RAM, ya que sus datos pueden ser alterados.
5.5 Instrucciones a utilizar. Nemónico Significado Descripción
RETLW k Return with Literal in W
Produce el retorno de una subrutina pero con un valor k en el registro W.
DT k,k,k…. Define Table Sustituye el empleo repetitivo de muchas instrucciones RETLW para facilitar su uso en el ensamblador MPASM. Genera durante la fase de ensamblado una instrucción RETLW por cada literal k.
5.6 Procedimiento 1. Crear un Nuevo Proyecto.
2. Crear una capeta para el Proyecto llamada Lab2
3. Agregar un nuevo Archivo al Proyecto.
4. Copiar el Código 5.2 Disp_7seg
Código 5.2 Disp_7seg
list p=16f887 ; list directive to define processor
#include <p16f887.inc> ; processor specific variable definitions
__CONFIG _CONFIG1, _LVP_OFF & _FCMEN_ON & _IESO_OFF & _BOR_OFF & _CPD_OFF &
_CP_OFF & _MCLRE_ON & _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT
__CONFIG _CONFIG2, _WRT_OFF & _BOR21V
ORG 0x000 ; Vector de Reset del procesador
main
BANKSEL ANSEL ;Seleccionamos el Banco al que pertenece ANSEL (Banco 3)
CLRF ANSEL ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH
CLRF ANSELH ;para configurar todos los pines como digitales
BANKSEL TRISB ;Seleccionamos el Banco al que pertenece TRISB (Banco 1)
MOVLW b'11111111' ;Ponemos a 1 todos los bit de TRISB para configurar como
MOVWF TRISB ;entrada todos los pines de PORTB
CLRF TRISD ;Ponemos a 0 todos los bit de TRISD para configurar como
;salida todos los pines de PORTD
BANKSEL PORTB ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)
Principal
MOVF PORTB,W ;Lee la entrada
ANDLW b'00001111' ;Máscara para quedarse con el valor de las
;entradas correspondientes al nibble bajo.
CALL Bin_7Seg ;Convierte código binario a 7 segmentos del display.
MOVWF PORTD ;Resultado se visualiza por el puerto de salida.
GOTO Principal
; Subrutina "Binario_7Segmentos" --------------------------------------------------------
;
Bin_7Seg ;Tabla para display de 7 segmentos.
ADDWF PCL,F
Tabla
Autor: Luis Alberto Vargas Tijerino Página 30
RETLW 3Fh ;El código 7 segmentos para el "0".
RETLW 06h ;El código 7 segmentos para el "1".
RETLW 5Bh ;El código 7 segmentos para el "2".
RETLW 4Fh ;El código 7 segmentos para el "3".
RETLW 66h ;El código 7 segmentos para el "4".
RETLW 6Dh ;El código 7 segmentos para el "5".
RETLW 7Dh ;El código 7 segmentos para el "6".
RETLW 07h ;El código 7 segmentos para el "7".
RETLW 7Fh ;El código 7 segmentos para el "8".
RETLW 67h ;El código 7 segmentos para el "9".
RETLW 77h ;El código 7 segmentos para la "A".
RETLW 7Ch ;El código 7 segmentos para la "B".
RETLW 39h ;El código 7 segmentos para la "C".
RETLW 5Eh ;El código 7 segmentos para la "D".
RETLW 79h ;El código 7 segmentos para la "E".
RETLW 71h ;El código 7 segmentos para la "F".
; DT 3Fh, 06h, 5Bh, 4Fh, 66h, 6Dh, 7Dh, 07h, 7Fh, 6Fh ;Del "0" al "9"
; DT 77h, 7Ch, 39h, 5Eh, 79h, 71h ;"A", "B", "C", "D", "E" y "F".
END ;Fin del programa.
5. Compilar el proyecto
6. Crear el circuito en Proteus. Para ello será necesario buscar mediante la caja de búsqueda en la
ventana PICK DEVICE el PIC16F887, LOGICSTATE y 7SEG-COM-CATHODE.
11. Cargar el Archivo fuente, Realizar la simulación (CTRL+F12 para iniciar y F10 para ir paso a paso), Abrir
la ventana de observación y Agregar los Registros por Nombre ANSEL, ANSELH, PORTB, PORTD, TRISB
y TRISD.
7. Conteste las siguientes preguntas:
a. ¿Qué ocurre en la línea 22 sí se presiona F10 o F11?
b. ¿Cuál es el valor de PORTD sí el valor de PORTB es b’00010110’?
c. Comente las líneas 31 a la 46 y descomente las líneas 47 y 48 y conteste las preguntas 8 y 9 de
nuevo.
5.7 Trabajo Extra Clase. 1. Contesta las siguientes preguntas:
PIC16F887
PIC16F887
PIC16F887
Autor: Luis Alberto Vargas Tijerino Página 31
a. ¿Qué es Salto Indexado Descontrolado?
b. ¿A qué equivale una tabla en los lenguajes de alto nivel (C y Basic)?
2. Elaborar un programa en lenguaje ensamblador que realice un contador ascendente de 0 a 9 que se
incrementa si se activa el PIN RB0 y que lo muestre en un display de 7 segmentos ánodo común.
Autor: Luis Alberto Vargas Tijerino Página 32
Laboratorio 6: Macros
6.1 Objetivo Comprender el proceso que realizan los lenguajes de alto nivel mediante la implementación de macros en el
lenguaje ensamblador.
6.2 Introducción Como se ha observado en los laboratorios anteriores, se requiere de varias instrucciones de código en
lenguaje ensamblador para realizar una simple operación aritmética, lógica, iteraciones o bucles. La mayoría
de los compiladores de alto nivel utilizan instrucciones que nos facilitan el trabajo, todas estas instrucciones
nacen a partir de Macros del lenguaje ensamblador. Este laboratorio muestra una forma elemental de utilizar
macros para reducir la cantidad de código en lenguaje ensamblador necesario en un programa.
6.3 Macros Las macros son una potente herramienta del ensamblador que facilita la elaboración de programas. Una
macro consiste en una serie de instrucciones y directivas que se agrupan en una sola orden mayor de forma
que se comporta como una única instrucción cuando es invocada. Suele utilizarse para automatizar la
utilización de grupos de instrucciones usadas con frecuencia. Las macros pueden aceptar argumentos lo que
las hace muy flexibles.
Ates de que una macro pueda ser invocada en una línea del programa fuente como si se tratase de una
instrucción, debe ser definida por el diseñador de acuerdo a la siguiente sintaxis:
<label> MACRO [<arg>,<arg>,...,<arg>]
.
.
.
ENDM
Donde <label> es una etiqueta que define a la macro y <arg> es cualquier número de argumentos opcionales
que se le proporciona a la macro. Los valores asignados a estos argumentos cuando se invoca la macro serán
posteriormente sustituidos por los nombres de los argumentos que se encuentran dentro de la macro.
El cuerpo de la macro puede contener instrucciones o directivas. El ensamblador ejecuta el procesado de la
macro hasta que encuentra alguna directiva de fin de la macro, generalmente ENDM.
Una vez que la macro ha sido definida puede ser invocada en cualquier punto del programa utilizando una
llamada a la macro con el siguiente formato:
<macro_name> [<arg>,…, <arg>
Donde <macro_name> es el nombre de la macro previamente definida. Hay que proporcionarle los
argumentos <arg> solicitados en la definición de la macro.
Autor: Luis Alberto Vargas Tijerino Página 33
La macro no ocupa código máquina alguno mientras no sea invocada, cuando esto ocurre la macro se
expandirá en el lugar del programa en que se encuentre.
6.4 Procedimiento 8. Crear un Nuevo Proyecto.
9. Crear una capeta para el Proyecto llamada Lab2
10. Agregar un nuevo Archivo al Proyecto.
11. Copiar el Código 6.1
Código 6.1 Macros
list p=16f887 ; list directive to define processor
#include <p16f887.inc> ; processor specific variable definitions
__CONFIG _CONFIG1, _LVP_OFF & _FCMEN_ON & _IESO_OFF & _BOR_OFF & _CPD_OFF &
_CP_OFF & _MCLRE_ON & _PWRTE_ON & _WDT_OFF & _INTRC_OSC_NOCLKOUT
__CONFIG _CONFIG2, _WRT_OFF & _BOR21V
;--------------------------------------------------------------------------------
;Macro Suma_var_lit suma una variable mas un literal y lo almacena en un registro
;--------------------------------------------------------------------------------
Suma_var_lit MACRO OUT_VAR,IN_VAR,IN_LIT
MOVLW IN_LIT
ADDWF IN_VAR,W
MOVWF OUT_VAR
ENDM
;--------------------------------------------------------------------------------
ORG 0x000 ; Vector de Reset del procesador
main
BANKSEL ANSEL ;Seleccionamos el Banco al que pertenece ANSEL (Banco 3)
CLRF ANSEL ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH
CLRF ANSELH ;para configurar todos los pines como digitales
BANKSEL TRISB ;Seleccionamos el Banco al que pertenece TRISB (Banco 1)
MOVLW b'11111111' ;Ponemos a 1 todos los bit de TRISB para configurar como
MOVWF TRISB ;entrada todos los pines de PORTB
CLRF TRISD ;Ponemos a 0 todos los bit de TRISD para configurar como
;salida todos los pines de PORTD
BANKSEL PORTB ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)
bucle
Suma_var_lit PORTD,PORTB,D'123' ;PORTD=PORTB+D'123'
GOTO bucle
END
12. Compilar el proyecto
13. Crear el circuito en Proteus. Para ello será necesario buscar mediante la caja de búsqueda en la
ventana PICK DEVICE el PIC16F887, LOGICSTATE y LOGICPROBE.
Autor: Luis Alberto Vargas Tijerino Página 34
12. Cargar el Archivo fuente, Realizar la simulación (CTRL+F12 para iniciar y F10 para ir paso a paso), Abrir
la ventana de observación y Agregar los Registros por Nombre ANSEL, ANSELH, PORTB, PORTD, TRISB
y TRISD.
13. Conteste las siguientes preguntas:
a. ¿Qué ocurre en la línea 30 al presionar F10 o F11?
b. En la ventana PIC CPU Source Code de clic derecho y seleccione Dissambly y conteste cuantas
líneas de código equivalen las líneas 10-13 y 30.
c. Comente la línea 30 y descomente las líneas 31 a 33 y conteste nuevamente las preguntas a y b.
6.5 Trabajo Extra clase 1. Contestar las siguientes preguntas:
a. ¿Cuándo es recomendable utilizar un MACRO en vez de una Subrutina?
b. ¿Es posible que un Macro sirva para llamar una Subrutina?
2. Elabore un programa en lenguaje ensamblador utilizando Macros que realice lo siguiente:
a. PORTD = PORTB + PORTA
b. PORTC = PORTB – PORTA
PIC16F887
LOGICPROBE
LOGICSTATE
Top Related