Laboratorios Ensamblador

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


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.8 Procedimiento ........................................................................................................................................ 25


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.6 Procedimiento ........................................................................................................................................ 29


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


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.

www.microchip.com


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.


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.


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.


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


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


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


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)


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)


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


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


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







main



;BSF STATUS,RP1 ;Ponemos a uno el bit RP1 del registro STATUS

;BSF STATUS,RP0 ;Ponemos a uno el bit RP0 del registro STATUS




;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




;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.


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


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?


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=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


(d)=(w) and (f) Z



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



(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



(d)=(w) xor (f) Z

COMF f,d NOT f Efectúa la operación NOT entre de f



(d)=not (f) Z

RLF f,d Shift Left f Desplaza un bit hacia la izquierda a f



(d)= (f)<<1 C

RRF f,d Shift Right f Desplaza un bit hacia la derecha a f



(d)= (f)>>1 C

SWAPF f,d Swap Nibbles f Intercambia los Nibbles de 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





4. Copiar el Código 3.1 Inst_ari_log

Código 3.1 Inst_ari_log






VAR1 EQU 0X20

VAR2 EQU 0X21

VAR3 EQU 0X23


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


ANDWF VAR1,F

SWAPF VAR1,F

GOTO main




ventana PICK DEVICE el PIC16F887.


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


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


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.


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)


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=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=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





4. Copiar el Código 4.1 Led_blink

Código 4.1 Led_blink






CBLOCK 0X20 ;Inicio del bloque de variables en la direccion 0x20

VAR1 ;VAR1 se declara en la direccion 0x20



ENDC


main

BANKSEL TRISD ;Seleccionamos el Banco al que pertenece TRISB (Banco 1)



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


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



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


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.


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 6Dh ; El código 7 segmentos para el "5".

retlw 7Dh ; El código 7 segmentos para el "6".


retlw 7Fh ; El código 7 segmentos para el "8".


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".


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.




4. Copiar el Código 5.2 Disp_7seg

Código 5.2 Disp_7seg







main





MOVLW b'11111111' ;Ponemos a 1 todos los bit de TRISB para configurar como

MOVWF TRISB ;entrada todos los pines de PORTB




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


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 6Dh ;El código 7 segmentos para el "5".

RETLW 7Dh ;El código 7 segmentos para el "6".




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.



ventana PICK DEVICE el PIC16F887, LOGICSTATE y 7SEG-COM-CATHODE.



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


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.


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.


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.




11. Copiar el Código 6.1

Código 6.1 Macros






;--------------------------------------------------------------------------------

;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

;--------------------------------------------------------------------------------


main





MOVLW b'11111111' ;Ponemos a 1 todos los bit de TRISB para configurar como

MOVWF TRISB ;entrada todos los pines de PORTB




bucle

Suma_var_lit PORTD,PORTB,D'123' ;PORTD=PORTB+D'123'

GOTO bucle

END



ventana PICK DEVICE el PIC16F887, LOGICSTATE y LOGICPROBE.




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

Documents

Laboratorios Ensamblador