Guías de PIC en lenguaje ensamblador

Universidad Nacional de Ingeniería Facultad de Electrotecnia y Computación Departamento de Sistemas Digitales y Telecomunicaciones

Guías de Laboratorios de Máquinas Computadoras I Luis Alberto Vargas Tijerino

2011

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 1

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


4.8

Procedimiento ........................................................................................................................................ 25

4.9


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


5.6

Procedimiento ........................................................................................................................................ 29

5.7


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


Página 2

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.


Página 3

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.


Página 4

1.4.3 1. 2. 3.

Crear una capeta para el Proyecto En el cuadro de Texto “Create New Project” escribir C:\laboratorios\lab1. Presionar el botón Next. 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.


Página 5

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 #include

p=16f887

; list directive to define processor ; 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

BANKSEL CLRF CLRF BANKSEL MOVLW MOVWF

ANSEL ANSEL ANSELH TRISB B'11111111' TRISB

CLRF

TRISD PORTB

;Seleccionamos el Banco al que pertenece ANSEL (Banco 3) ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH ;para configurar todos los pines como digitales ;Seleccionamos el Banco al que pertenece TRISB (Banco 1) ;Movemos el literal B'11111111' al registro de trabajo ;Movemos el dato del registro de trabajo al registro TRISB ;Para configurar todos los pines de PORTB como entrada ;Ponemos a 0 todos los bit de TRISD para configurar como ;salida todos los pines de PORTD ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)

PORTB,W PORTD bucle

;Movemos el dato del registro PORTB al registro de trabajo ;Movemos el dato del registro de trabajo al registro PORTD ;Salta hacia la siguiente linea despues de la etiqueta bucle.

main

BANKSEL bucle MOVF MOVWF GOTO


Página 6

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

Caja de Busqueda

Ventana de dispositivos seleccionados


Lista de Resultados

Página 7

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

Ventana de Trabajo.

Ventana de dispositivos seleccionados Barra de Simulación

LOGICPROBE

PIC16F887 LOGICSTATE

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 1. 2. 3.

Cargar el Archivo fuente Darle doble clic al PIC16F887 ubicado en la ventana de trabajo Darle clic al botón de la caja de texto Program File y seleccionar el archivo fuente Inst_Bas.cof Cambiar la frecuencia de reloj a 8MHz.


Página 8

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


Página 9

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 el usuario.

o combinación Ctrl+F10: Ubica al depurador en la línea seleccionada por

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)


Página 10

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)


Página 11

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


Página 12

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

ORG k BANKSEL f CLRW CLRF f

Bank Select f Clear w Clear f

MOLW k MOVF f,d

Move w Move f

MOVWF f MOVFW f BCF f,b BSF f,b GOTO k

Move w to f Move f to w Bit Clear f Bit Set f Go To k

Descripción Indica la dirección k en la que se iniciará el código siguiente. Selecciona el Banco al que pertenece el registro f El contenido del registro w se borra asignándole b’0000_0000’. Borra el contenido del registro fuente asignándole b’0000_0000’. Mueve el valor de la constante k al registro w. 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. Mueve el valor del registro w al registro f Mueve el valor del registro f al registro w Pone a cero el bit b del registro f Pone a uno el bit b del registro f Salta hacia la dirección especificada por k, el cual puede ser una


Flags afectados RPx Z Z

Z

Página 13

END

End of Program

etiqueta o una constante. 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 Decimal

Hexadecimal

Octal Binario ASCII

“String” o Cadena

Sintaxis D’’ d’’ . H’’ h’’ 0x H h O’’ o’’ B’’ b’’ A’’ a’’ ‘’ “”

Ejemplo MOVLW D‟109‟ MOVLW d‟109‟ MOVLW .109 MOVLW H‟6D‟ MOVLW h‟6D‟ MOVLW 0x6D MOVLW 6DH MOVLW 6Dh MOVLW O‟155‟ MOVLW o‟155‟ MOVLW B‟01101101‟ MOVLW b‟01101101‟ MOVLW A‟M‟ MOVLW a‟M‟ MOVLW „M‟ DT “Hola”

2.5 Procedimiento 1. 2. 3. 4.

Crear un Nuevo Proyecto. Crear una capeta para el Proyecto llamada Lab2 Agregar un nuevo Archivo al Proyecto. Copiar el Código 2.1 Inst_Bas.asm

Código 2.1 Inst_Bas.asm

list #include

p=16f887



0x000


main BANKSEL ANSEL

;Seleccionamos el Banco al que pertenece ANSEL (Banco 3)


Página 14

;BSF ;BSF CLRF CLRF BANKSEL ;BCF MOVLW MOVLW MOVLW MOVLW MOVWF

STATUS,RP1 STATUS,RP0 ANSEL ANSELH TRISB STATUS,RP0 B'11111111' .255 0XFF O'177' TRISB

;Ponemos a uno el bit RP1 del registro STATUS ;Ponemos a uno el bit RP0 del registro STATUS ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH ;para configurar todos los pines como digitales ;Seleccionamos el Banco al que pertenece TRISB (Banco 1) ;Ponemos a cero el bit RP0 del registro STATUS ;Movemos el literal B'11111111' al registro de trabajo ;Movemos el literal .255 al registro de trabajo ;Movemos el literal 0XFF al registro de trabajo ;Movemos el literal O'177' al registro de trabajo ;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.

LOGICSTATE

PIC16F887

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: Autor: Luis Alberto Vargas Tijerino

Página 15

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?


Página 16

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

ADDLW k

Add k to W

ADDWF f,d

Add w and f

SUBLW k SUBWF f,d

Subtract k to W Subtract w and f

DECF f,d

Decrement f

INCF f,d

Increment f

ANDLW k ANDWF f,d

AND k with w AND w with f

Descripción

Operación

Suma el contenido del registro w con el valor del literal k. 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. Resta el registro w menos el literal k. 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. 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. 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. Efectúa la operación AND entre w y k Efectúa la operación AND entre w y f  Si d=0 o d=w el resultado se almacena en w.

(w)=(w)+k

Flags afectados Z, C, DC

(d)=(w)+(f)

Z, C, DC

(w)=(w)-k (d)=(w)-(f)

Z, C Z, C

(d)=(f)-1

Z, C

(d)=(f)+1

Z, C, DC

(w)=(w) and k (d)=(w) and (f)

Z Z


Página 17



IORLW k IORWF f,d

OR k with w OR w with f

XORLW k XORWF f,d

XOR k with w XOR w with f

COMF f,d

NOT f

RLF f,d

Shift Left f

RRF f,d

Shift Right f

SWAPF f,d

Swap Nibbles f

Si d=1 o d=f el resultado se almacena en f. Efectúa la operación OR entre w y k 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. Efectúa la operación XOR entre w y k 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. 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. 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. 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. 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.

(w)=(w) or k (d)=(w) or (f)

Z Z

(w)=(w) xor k (d)=(w) xor (f)

Z Z

(d)=not (f)

Z

(d)= (f)<<1

C

(d)= (f)>>1

C

(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 18

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 #include

p=16f887


__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


BANKSEL CLRF CLRF CLRF MOVLW ADDLW ADDWF SUBLW SUBWF INCF DECF ANDLW ANDWF IORLW IORWF XORLW XORWF RLF RRF SWAPF

VAR1 VAR1 VAR2 VAR3 23 45 VAR1,W 51 VAR1,F VAR1,F VAR2,W 0X0F VAR2,F 0XF0 VAR3,F B'01010101' VAR3,F VAR1,F VAR1,F VAR1,F

;Seleccionamos el Banco al que pertenece VAR1 ;VAR1 = 0 ;VAR2 = 0 ;VAR3 = 0 ;W = 0x23 ;W = W + 0x45 ;W = VAR1 + W ;W = 51 - W ;VAR1 = VAR1-W ;VAR1 = VAR1 + 1 ;W = VAR2 - 1 ;W =W and 0x0F (Ponemos el Nibble Alto de W en bajo) ;VAR2=VAR2 and W ;W = W or 0XF0 (Ponemos el Nible Alto de W en alto) ;VAR3 = W or VAR3 ;W = W xor B'01010101' ;VAR3 = VAR3 xor W ;Desplazamos un bit a la izquierda VAR1 ;Desplazamos un bit a la derecha VAR2 ;Intercambiamos los Nibbles

main

;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


Página 19

ANDWF SWAPF

VAR1,F 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


Página 20

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


Página 21

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.


Página 22

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)


Página 23

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 BTFSC f,b BTFSS f,b DECFSZ f,d

INCFSZ f,d

NOP CALL k RETURN CBLOCK k ENDC

Significado Bit Test f, Skip if Clear Bit Test f, Skip if Set Decrement f, Skip if Zero

Descripción Ignora y salta la instrucción que sigue a esta si el bit b es cero. Ignora y salta la instrucción que sigue a esta si el bit b es uno. 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. Increment f, Skip if Incrementa en uno el contenido del registro f, ignora y salta la Zero 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. No Operation No realiza operación alguna. Se utiliza para consumir un ciclo máquina sin hacer nada. Call address k Provoca que la ejecución del programa se transfiera a la subrutina. Return Provoca el retorno a la dirección que sigue al CALL que realizó la última llamada. Constant Block Define un bloque de variables que se almacenaran en la memoria RAM comenzando desde la dirección k End Constant Block Indica el fin del bloque de variables


Página 24


Crear un Nuevo Proyecto. Crear una capeta para el Proyecto llamada Lab2 Agregar un nuevo Archivo al Proyecto. Copiar el Código 4.1 Led_blink

Código 4.1 Led_blink

list #include

p=16f887


__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 VAR1 VAR2 VAR3 ENDC

;Inicio del bloque de variables en la direccion 0x20 ;VAR1 se declara en la direccion 0x20 ;VAR2 se declara en la direccion 0x21 ;VAR3 se declara en la direccion 0x22

ORG


0x000

main BANKSEL TRISD CLRF TRISD BANKSEL PORTD bucle MOVLW CALL movlw CALL BTFSS GOTO Led_of BCF GOTO Led_on BSF GOTO

;Seleccionamos el Banco al ;Ponemos a 0 todos los bit ;salida todos los pines de ;Seleccionamos el Banco al

que pertenece TRISB (Banco 1) de TRISD para configurar como PORTD que pertenece PORTB (Banco 0)

.5 Retardo_us .250 Retardo_ms PORTD,0 Led_on

;Mover al registro W el valor 5 decimal ;Llamar a la rutina Retardo_us (tardara 4 + 4x5=24 ciclos) ;Mover al registro W el valor 250 decimal ;Llamar a la rutina Retardo_ms (tardara 4 + 2003 x 250 ciclos) ;Probar si el bit 0 de PORTD es 1 ;si es 0 saltar a Led_ond

PORTD,0 bucle

;Poner a 0 el bit 0 de PORTD (Apagar LED) ;Saltar a bucle

PORTD,0 bucle

;Poner a 1 el bit 0 del PORTD (Encender Led) ;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


Página 25

call decfsz goto return

Retardo_us ;1000M R_Cont2,F ;M+1 Ciclo_ms ;2M-2 ;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. PIC16F887

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.


Página 26

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.


Página 27

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


Página 28

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 RETLW k DT k,k,k….

Significado Descripción Return with Literal in Produce el retorno de una subrutina pero con un valor k en el W registro W. 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.


Crear un Nuevo Proyecto. Crear una capeta para el Proyecto llamada Lab2 Agregar un nuevo Archivo al Proyecto. Copiar el Código 5.2 Disp_7seg

Código 5.2 Disp_7seg

list #include

p=16f887



0x000


BANKSEL CLRF CLRF BANKSEL MOVLW MOVWF CLRF

ANSEL ANSEL ANSELH TRISB b'11111111' TRISB TRISD

;Seleccionamos el Banco al que pertenece ANSEL (Banco 3) ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH ;para configurar todos los pines como digitales ;Seleccionamos el Banco al que pertenece TRISB (Banco 1) ;Ponemos a 1 todos los bit de TRISB para configurar como ;entrada todos los pines de PORTB ;Ponemos a 0 todos los bit de TRISD para configurar como ;salida todos los pines de PORTD ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)

main

BANKSEL 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


Página 29

; ;

RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW RETLW DT DT

3Fh ;El código 7 06h ;El código 5Bh ;El código 4Fh ;El código 66h ;El código 6Dh ;El código 7Dh ;El código 07h ;El código 7Fh ;El código 67h ;El código 77h ;El código 7Ch ;El código 39h ;El código 5Eh ;El código 79h ;El código 71h ;El código 3Fh, 06h, 5Bh, 4Fh, 66h, 77h, 7Ch, 39h, 5Eh, 79h,

END

segmentos para el "0". 7 segmentos para el "1". 7 segmentos para el "2". 7 segmentos para el "3". 7 segmentos para el "4". 7 segmentos para el "5". 7 segmentos para el "6". 7 segmentos para el "7". 7 segmentos para el "8". 7 segmentos para el "9". 7 segmentos para la "A". 7 segmentos para la "B". 7 segmentos para la "C". 7 segmentos para la "D". 7 segmentos para la "E". 7 segmentos para la "F". 6Dh, 7Dh, 07h, 7Fh, 6Fh ;Del "0" al "9" 71h ;"A", "B", "C", "D", "E" y "F".

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

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: Autor: Luis Alberto Vargas Tijerino

Página 30

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.


Página 31

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: MACRO [,,...,] . . . ENDM

Donde es una etiqueta que define a la macro y 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: [,…, Donde es el nombre de la macro previamente definida. Hay que proporcionarle los argumentos solicitados en la definición de la macro. Autor: Luis Alberto Vargas Tijerino

Página 32

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 #include

p=16f887


__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


BANKSEL CLRF CLRF BANKSEL MOVLW MOVWF CLRF

ANSEL ANSEL ANSELH TRISB b'11111111' TRISB TRISD

;Seleccionamos el Banco al que pertenece ANSEL (Banco 3) ;Ponemos a 0 todos los bit del registro ANSEL y ANSELH ;para configurar todos los pines como digitales ;Seleccionamos el Banco al que pertenece TRISB (Banco 1) ;Ponemos a 1 todos los bit de TRISB para configurar como ;entrada todos los pines de PORTB ;Ponemos a 0 todos los bit de TRISD para configurar como ;salida todos los pines de PORTD ;Seleccionamos el Banco al que pertenece PORTB (Banco 0)

main

BANKSEL PORTB 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.


Página 33

LOGICSTATE

PIC16F887

LOGICPROBE

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 Autor: Luis Alberto Vargas Tijerino

Página 34

Guías de PIC en lenguaje ensamblador

Recommend Documents