Instituto Politécnico Nacional.

Escuela Superior de Ingeniería Mecánica y

Eléctrica.
Ingeniería en Comunicaciones y Electrónica.
Asignatura:
Microprocesadores.
Profesor:
Bravo León José Luis.
Alumna:
Hernández Vargas Michel.
Número de Boleta:
2016300761
Grupo:
6CM2
Práctica #2 “MPLAB”
Primer Parcial
Ciclo Escolar
2018-2019.
Contenido

Objetivos Generales ........................................................................................................................................... 2

Objetivo Particular de la Práctica ....................................................................................................................... 2
Material .............................................................................................................................................................. 2
Introducción Teórica .......................................................................................................................................... 2
El ensamblador y enlazador........................................................................................................................... 2
Historia de MPLAB .......................................................................................................................................... 5
Desarrollo de la Práctica ..................................................................................................................................... 6
Experimento #1 MPLAB .................................................................................................................................. 6
Cuestionario ..................................................................................................................................................... 13
Evidencia de la práctica .................................................................................................................................... 13
Conclusiones ..................................................................................................................................................... 14
Bibliografía........................................................................................................................................................ 14

1|P á g i n a
Objetivos Generales

Utilizar las herramientas de desarrollo de MPLAB

Objetivo Particular de la Práctica

Que el alumno realice la práctica de MPLAB que otorgó el profesor, para aprender
y conocer el funcionamiento para el PIC18F4550 que vamos a utilizar durante el
curso y conocer la dirección y código de las instrucciones del programa en esta
práctica, para saber cómo se utiliza dicho programa.

Material

 Software de desarrollo MPLAB IDE

 Plantilla forma.asm
 Manual del PIC18F4550

Introducción Teórica
El ensamblador y enlazador

El programa ensamblador convierte un módulo fuente simbólico (archivo) en un

archivo objeto hexadecimal. El ejemplo 7.1 muestra cómo se ensambla el dialogo
de un ensamblador que aparece como un módulo de fuente llamado new.asm.
Observe que este dialogo se utiliza con la versión 6.11 en la línea de comandos del
dos. Este ensamblador también utiliza Programmer`s WorkBench para el desarrollo,
sin recurrir a la línea de comandos del Dos. Siempre que usted genere un archivo
fuente, deberá tener una extensión ASM. Los archivos fuente se crean empleando
WorkBench un editor incluido con el ensamblador, o con casi cualquier otro
procesador de texto o editor capaz de generar un archivo ASCII.

Ejemplo 7.1
C:/ MASM611/FILES>ml/Flnew.lst new.asm
Microsoft ® Macro Assambler Versión 6.11
Copyright © Microsoft Corp 1981-1993. All rights reserved
Assembling: new.asm
Microsoft ® Segmented Executable Linker Version 5.31.009 July 13 1992
Copyright © Microsoft Corp 1984-1992. All rights reserved.

2|P á g i n a
Object Modules (.obj) : new.obj
Run File (new.exe) : “new.exe”
List File (nul.map) : NUL
Libraries (.lib):
Definitions File (nil.def) :
C: /MASM611/FILES >

El programa ensamblador (ML) requiere que el nombre del archive siga a ML. En el
ejemplo, se emplea el modificador /F1 para crear un listado del archivo llamado
NEW.LST. Aunque esto es opcional, es recomendable hacerlo para que el resultado
del ensamblador puede ser visualizado del archivo fuente y sus equivalentes en
lenguaje máquina hexadecimal. El archivo de referencia cruzada (. CRF)- que no es
generando en este ejemplo- muestra todas las etiquetas y la información pertinente
requerida para hacer referencia cruzada.
El programa enlazador que se ejecuta como la segunda parte de ML lee los
archivos objeto que crea el programa ensamblador y los une un archivo ejecutable.
Un archivo ejecutable se crea con la extensión del archivo EXE. Los archivos
ejecutables son seleccionados al introducir el nombre correspondiente en la
solicitud de comando del Dos (A:/). Un ejemplo de archivo ejecutable es FROG.EXE,
el cual se ejecuta al escribir “FROG” en la línea de comandos del DOS.
Si el archivo es suficiente pequeño (de menos de 64KB) puede convertirse de
archivo ejecutable a archivo de comando (.COM). El archivo de comando difiere
ligeramente de uno ejecutable, dado que el programa debe comenzar en la localidad
100H antes de poder ser ejecutado. Esto significa que el programa debe tener una
longitud de menor a 64K-100H. El programa ML genera un archivo de comando
cuando se emplea el modelo TINY con la dirección de inicio 100H. Observe que
Programmer´s WorkBench también puede configurarse para generar un archivo de
comando. La ventaja principal de un archivo de comando es que se carga del disco
a la computadora mucho más rápidamente que un archivo ejecutable. También
requiere un espacio de almacenamiento en disco menor que su equivalente
ejecutable.
El ejemplo 7-2 muestra el protocolo del programa enlazador cuando se utiliza para
enlazar los archivos NEW,WHAT Y DONUT. El enlazador también enlaza archivos
de biblioteca (LIBS), de manera que los procedimientos ubicados dentro de los LIBS
pueden ser utilizados con el archivo ejecutable enlazado. Para llamar al enlazador,
escriba LINK en la línea de comandos del DOS, como se muestra en el ejemplo 7-
2. Observe que antes de que los archivos sean enlazados, primeros deben ser

3|P á g i n a
ensamblados y estar libres de errores. ML no sólo enlaza archivo, sino que también
los ensambla antes de enlazarlos.

Ejemplo 7-2

C:/ MASM611/FILES>ml/Flnew.lst new.asm what.asm donut.asm

Microsoft ® Macro Assambler Versión 6.11
Copyright © Microsoft Corp 1981-1993. All rights reserved

Assembling: new.asm
Assembling: what.asm
Assembling: donut.asm

Microsoft ® Segmented Executable Linker Version 5.31.009 July 13 1992

Copyright © Microsoft Corp 1984-1992. All rights reserved.

Object Modules (.obj) : new.obj+

Object Modules (.obj) : what.obj+
Object Modules (.obj) : donut.obj+
Run File (new.exe) : “new.exe”
List File (nul.map) : NUL
Libraries (.lib):
Definitions File (nil.def) :
C: /MASM611/FILES >

En este ejemplo, después de escribir ML, el programa enlazador pide los “módulos
de objetos” creados por el ensamblador. En este ejemplo, tenemos tres módulos
objeto: NEW, WHAT y DONUT. Si existe más de un archivo objeto, primero se
escribe el nombre del archivo del programa principal (en este ejemplo NEW),
seguido por los demás módulos.
Los archivos de biblioteca se escriben después del nombre del archivo y después
del modificador /LINK. En este ejemplo, no escribimos un nombre de archivo de
biblioteca. Si deseara utilizar una biblioteca llamada NUMB.LIB durante el

4|P á g i n a
ensamblado de un programa llamado NEW.ASM, tendría que escribir ML
NEW.ASM/LINK NUMB.LIB.

Historia de MPLAB

MPLAB es un editor IDE gratuito, destinado a productos de la marca Microchip.

Este editor es modular, permite seleccionar los
distintos microcontroladores soportados, además de permitir la grabación de
estos circuitos integrados directamente al programador.
Es un programa que corre bajo Windows, Mac OS y Linux. Presenta las clásicas
barras de programa, de menú, de herramientas de estado, etc. El ambiente
MPLAB® posee editor de texto, compilador y simulación (no en tiempo real). Para
comenzar un programa desde cero para luego grabarlo al μC en MPLAB® v7.XX
los pasos a seguir son:

1. Crear un nuevo archivo con extensión .ASM y nombre cualquiera

2. Crear un Proyecto nuevo eligiendo un nombre y ubicación
3. Agregar el archivo .ASM como un SOURCE FILE
4. Elegir el microcontrolador a utilizar desde SELECT DEVICE del menú
CONFIGURE
Una vez realizado esto, se está en condiciones de empezar a escribir el programa
respetando las directivas necesarias y la sintaxis para luego compilarlo y grabarlo
en el PIC.

5|P á g i n a
Desarrollo de la Práctica

Experimento #1 MPLAB

1. Se instalo el programa MPLAB, en la computadora.

2. Se realiza una carpeta, para poder empezar a trabajar en el proyecto y se

mete adentro de la carpeta la plantilla forma.asm y le cambio el nombre y le
pongo práctica número 2.

6|P á g i n a
3. Abrí el programa MLAB y genere mi proyecto en donde dice Proyect y cree
un Project Wizard, donde seleccione el PIC18F4550 le di continuar,
seleccione la herramienta que dice MPASM Assambler (mpasmwin.exe) v
5.51.

4. Seleccione el botón Browse, para poder salvar mi proyecto, le asigne el

nombre de práctica 2 como lo hice con la plantilla.asm y le di guardar y me
genero la pantalla que se muestra a continuación donde se asignara, la
plantilla.asm y se finalizara el proceso para empezar a generar el código para
que se ejecutarlo y revisar su funcionamiento.

7|P á g i n a
5. Aparece una ventana muy pequeña con un monto de carpetas y dentro de la
carpeta de source files dice practica 2, le doy doble clic y me abre una
plantilla donde, voy a poder ingresar las instrucciones que yo quiera, o mejor
dicho el código que quiera realizar, como se muestra a continuación:

6. Antes de realizar un código siempre se tiene que realizar un diagrama de

flujo, para ver si la secuencia que queremos tener sobre el programa es
correcta.

8|P á g i n a
 7. En este caso generaremos un diagrama de flujo que realice un
direccionamiento directo para leer de un área de memoria que inicia en la
dirección 0050H, con cinco datos almacenados en código BCD, realizar una
conversión correspondiente para código ASCII y los almacene en la misma
memoria. A continuación, se muestra el diagrama de flujo, que se realiza:

8. Después, de haber realizado el diagrama de flujo, procedemos a agregar las

instrucciones en donde tenemos la edición del programa creado.

Significado de algunas instrucciones de MPLAB

Movf Mover

Addlw Añadir algo

Movlw Muevo esa constante al

acumulador/registro.

9|P á g i n a
 En esta imagen, se muestra
la edición del programa,
respecto al diagrama de
flujo, que realizamos. Y
podemos observar la
secuencia de instrucciones
realizadas.

9. Compilamos el programa, para verificar que al momento haber hecho la

edición del código no nos hubiéramos equivocado, si la realización del código
fue la correcta, nos aparecerá una pantalla donde diga que esta
correctamente compilado, se muestra a continuación:

10 | P á g i n a
 10. Después de haber compilado el programo procedemos a realizar la
activación de los registros, donde selecciona la opción que diga View y
damos clic a la opción watch, nos aparecerá una tabla, como se mostrará a
continuación:

Donde para agregar

WREG, PCL y PORTB.
Me dirijo a la opción de
Add SFR y ahí
buscamos una por una y
le damos después en
Add Symbol y se van
agregando 1 por 1, hasta
que las tengamos como
en la captura de pantalla
que observamos.

11. Me dirijo opción que diga view y se me desplegará una ventana donde le
seleccionare file registers y me desplegará una tabla de registros de
memoria y me permitirá introducir datos BCD a 5 diferentes localidades en
dirección 50H (hexadecimal), como a continuación, se muestra:

En esta imagen se muestra la tabla para introducir los registros de memoria en el

número 050H como lo indica el cuadro de color morado.
12. Por último, nos iremos a la Step Into y colocamos ese pequeño apuntador
a la primera instrucción de nuestro código para la ejecución del programa y
nos proporcione la instrucción que necesitamos llenar en la siguiente tabla
que se mostrara a continuación:

11 | P á g i n a
Dirección Código Instrucción PCL W 50 51 52 53 54

001000 5050 movf 0x50,0 0x00 0x00 04 06 03 09 01

001002 0F30 addlw 0x30 0x02 0x04 04 06 03 09 01

001004 6E50 movwf 0x50 0x04 0x34 04 06 03 09 01

001006 5051 movf 0x51,0 0x06 0x34 34 06 03 09 01

001008 0F30 addlw 0x30 0x08 0x06 34 06 03 09 01

00100A 6E51 movwf 0x51 0x0A 0x36 34 06 03 09 01

00100C 5052 movf 0x52,0 0x0C 0x36 34 36 03 09 01

00100E 0F30 addlw 0x30 0x0E 0x03 34 36 03 09 01

001010 6E52 movwf 0x52 0x10 0x33 34 36 03 09 01

001012 5053 movf 0x53,0 0x12 0x33 34 36 33 09 01

001014 0F30 addlw 0x30 0x14 0x09 34 36 33 09 01

001016 6E53 movwf 0x53 0x16 0x39 34 36 33 09 01

001018 5054 movf 0x54,0 0x18 0x39 34 36 33 39 01

00101A 0F30 addlw 0x30 0x1A 0x01 34 36 33 39 01

00101C 6E54 movwf 0x54 0X1C 0x31 34 36 33 39 01

12 | P á g i n a
Cuestionario

1. ¿Qué relación existe entre el registro PCL y las direcciones de las

instrucciones del programa?
Los saltos que da a la línea de instrucciones es de 2 bytes.
2. ¿Cuál es la dirección inicial del programa?
Esta es la dirección inicial 0010000.
3. ¿Cuál es la dirección final del programa?
Esta es la dirección final 00101C.
4. ¿Cuál es la longitud total del programa?
La longitud del programa es de 30 bytes.
5. ¿Cuál sería el cambio en el código del programa si los registros de memoria
empleados fueran apartir de 0x40?
Que cambia más de una línea de código en el programa, porque ahora
en lugar de emplear 0x50 utilizamos 0x40 en el código.
6. ¿Cuál sería el cambio en el código del programa si la literal a sumar fuera de
0x20?
En lugar de sumar 0F30 a la literal, ahora le sumaras 0F20 a la literal.

Evidencia de la práctica

Imagen de una ejecución del programa en la última línea de código donde se

muestra que se está ejecutando en su totalidad el programa de manera correcta.

13 | P á g i n a
Conclusiones

En esta práctica, aprendimos a usar el software MPLAB y la plantilla.asm, como es

su funcionamiento del programa general, pero nosotros trabajamos con el PIC que
el profesor nos dio, para empezar a familiarizarnos más en este caso fue el PIC
18F4550 para el cual trabajamos y ejecutamos todas las instrucciones que se nos
indicaron. Nuestro principal objetivo aprender fue leer un área de memoria y
direccionar 5 datos almacenados y convertirlos en ASCII, donde al momento de
llenar la tabla en la práctica aprendí que:
Dirección: es un dispositivo receptor para una localización de memoria con la cual
un programa informático un dispositivo de hardware deben almacenar un dato para
su posterior reutilización.
Código: un programa informático (o software) es un conjunto de líneas de texto con
los pasos que debe seguir la computadora para ejecutar dicho programa.
Donde aprendí que la dirección ya viene establecida por el programa que estamos
usando, pero el código no son líneas que yo edito en la plantillla.asm, y las puedo
editar cuantas veces yo quiera y pueden variar, puedo editar desde 1 línea o todas.

Bibliografía

Autor: Barey B. BREY

Años de publicación: 2001
Título del Libro: Los Microprocesadores Intel
Ciudad y País: New Jersey
Editorial: Pearson

14 | P á g i n a