Este documento describe el emulador EMU8086, que se utiliza para aprender programación en ensamblador del microprocesador 8086. Explica que el EMU8086 proporciona un entorno de desarrollo integrado (IDE) que facilita la escritura, compilación y ejecución de código ensamblador. También describe los pasos para crear un nuevo proyecto, escribir código, compilarlo en un ejecutable y ejecutarlo dentro del emulador, monitoreando el proceso.

1. Microprocesadores C0112.
EMULADOR EMU8086
GENERALIDADES.
El Emulador EMU8086 es el primer programa que se utiliza en el curso de
Microprocesadores que imparte la Universidad Don Bosco; se ha elegido este emulador
porque posee una interfaz de usuario muy amigable que permite familiarizarse con los
fundamentos de la programación en lenguaje ensamblador de forma muy intuitiva, a
parte de eso brinda una serie de recursos para ejecutar y depurar los programas.
También tiene algunas desventajas como el hecho de no soportar algunas de las
interrupciones más interesantes que posee el sistema operativo y tampoco puede
acceder a los puertos físicos (reales), sino que los emula usando otros programas que
ya están incluidos en su respectiva carpeta.
Si ejecuta la versión 4.05 del EMU8086 observaría primero la pantalla de bienvenida
(welcome), similar a la que se muestra en la figura 1.
Figura 1. Pantalla de bienvenida del emulador EMU8086.
Se presentan cuatro diferentes opciones para elegir:
• New: Le permite escribir un nuevo código en lenguaje ensamblador (al que
llamaremos “Código Fuente” y tendrá extensión .ASM)
• Code examples: Le permite acceder a una serie de programas ejemplos que
pueden ayudarle a comprender funciones más complejas.

2. 2 Microprocesadores C0112.
• Quick start tutor: activa un conjunto de documentos de ayuda, se recomienda
revisarlos frecuentemente en caso de dudas.
• Recent file: Le muestra los últimos archivos que se trabajaron en la máquina.
Si se desea escribir un nuevo código fuente se debe seleccionar la opción New. Se
puede elegir una de cuatro posibles opciones para un nuevo código fuente como las
que se observan en la caja de dialogo “choose code template”, como se muestra en la
figura 2. Esta selección esté relacionada con el tipo de archivo final (archivo
ejecutable) que se desea generar.
Figura 2. Caja de dialogo para seleccionar el tipo plantilla (template).
En esta caja de dialogo se presentan seis opciones, cuatro de ellas le permiten usar
plantillas predefinidas con algunos de los tipo de archivo que se pueden crear en
lenguaje ensamblador: COM template, EXE template, BIN template y BOOT template
(cada uno le permite diferentes características que se abordaran a su debido tiempo en
el curso). Las otras dos que le permiten usar un espacio vacío “empty workspace” (sin
una plantilla) o activar el emulador mismo. Para el caso del curso de
Microprocesadores se seleccionará la opción del espacio vacío.
Para escribir los códigos fuentes se cuenta con la facilidad de tener un Entorno de
Desarrollo Integrado (Integrated Development Environme IDE), como se muestra en la
figura 3. Es importante hacer notar que en este ambiente es posible escribir códigos en
lenguaje de máquina y también usando los nemotécnicos y la sintaxis del lenguaje
ensamblador, éste último es el que se usará cotidianamente en el laboratorio.
Si se observa detenidamente la figura 3 Podrá verse una barra de menú de Windows
con sus opciones clásicas file, edit, etc. pero también se notan unas opciones poco
usuales como assembler, emulator, etc. propias de este programa. También se verá
una serie de botones que le permitirán crear un nuevo archivo (new), abrir un archivo
que ya existe (open), abrir un ejemplo (examples), compilar un archivo fuente
(compile), emular un archivo ejecutable (emulate), etc.

3. Microprocesadores C0112.
En el menú “Help” puede encontrar tutoriales sobre el emu8086, sobre lenguaje
ensamblador y un set de instrucciones e interrupciones para el 8086
Figura 3. Ventana de edición o Entorno de Desarrollo Integrado IDE del EMU8086.
LENGUAJES DE ALTO NIVEL Y EL LENGUAJE ENSAMBLADOR.
El lenguaje ensamblador, que es el que se estudiará en el curso de Microprocesadores
es del tipo estructurado (no está orientado a objetos) y su estructura tiene algunas
similitudes con otros lenguajes, para poner de manifiesto lo anterior se ha preparado
un ejemplo ilustrativo a ese respecto.
Primero estudie la tabla 1, donde se muestra el flujo-grama (desarrollado en FreeDFD)
y el código fuente (escrito en C) de un programa muy conocido.
FLUJO-GRAMA CODIGO FUENTE
#include <iostream.h>
#include <conio.h>
main()
{
char frase[12] = {"nnHOLA MUNDO"};
char pak[41] = {"nPresione cualquier tecla para continuar"};
cout<< frase;
cout<< pak;
getch();
return 0;
}
Tabla 1. Programa en lenguaje C.

4. 4 Microprocesadores C0112.
¿Qué hace el programa?
Note que el código fuente esta dividido en tres bloques: El encabezado que contiene
las directivas de preproceso que son necesarias para emplear las funciones de
biblioteca (#include). Las declaraciones donde se especifican las variables y
prototipos de funciones. Por último el cuerpo del programa donde se escriben
concretamente las funciones que ejecutará el programa.
A continuación, en la Figura 4 se muestra un flujo-grama un poco diferente porque
está orientado al lenguaje ensamblador. Note que se están usando tanto el símbolo de
“Proceso” como el de “Proceso predefinido” (Función) para diferenciar las instrucciones
de las funciones. En el texto de los proceso se menciona el término “Registro” que se
usa en el mismo sentido con el que se usa en Sistemas Digitales como una pequeña
memoria de baja capacidad. Estos registros se encuentran dentro del microprocesador
y se utilizan para almacenar datos o instrucciones que posteriormente serán
procesados.
INICIO 1
ALMACENA EN EL REGISTRO ACUMULADOR (AX) LA VUELVE A EJECUTAR “Imprimir_Cadena” PARA IMPRIMIR
DIRECCION DE MEMORIA A PARTIR DE LA CUAL SE HAN OTRA CADENA DE TEXTO, EN ESTE CASO LLAMADA “pak”
ALMACENADO LOS DATOS CON LOS QUE TRABAJARA
EL PROGRAMA
EJECUTAR LA MACRO-INSTRUCCIÓN LLAMADA
“Presione_Tecla_Fin” QUE ESPERA A QUE EL USUARIO DEL
TRANSFIERE (COPIA) EL CONTENIDO DEL REGISTRO PROGRAMA PRESIONE CUALQUIER TECLA PARA SEGUIR
ACUMULADOR (EN ESTE CASO LA DIRECCION DE ADELANTE CON LA EJECUCION DEL CODIGO.
MEMORIAL DESDE DONDE SE ALMACENAN LOS DATOS
CON LOS QUE TRABAJARA EL PROGRAMA) AL
REGISTRO SEGMENTO DE DATOS (DS).
ALMACENA EN EL REGISTRO ACUMULADOR EL VALOR
4C00h (NUMERO HEXADECIMAL) QUE SERA USADO POR
LA SIGUIE LINEA.
EJECUTA LA MACRO-INSTRUCCIÓN LLAMADA “Imprimir _Cadena” LA CUAL
IMPRIME UNA CADENA DE TEXTO ESTA CADENA SE ESPECIFICA AL
,
PASARLE UN PARAMETRO A LA MACRO-INSTRUCCIÓN, USANDO EL
NOMBRE DE LA CADENA QUE SE DESEA ESCRIBIR DESPUES DEL
LLAMADO A LA MACRO-INSTRUCCIÓN (en este caso llamada “frase”). EJECUTA INTERRUPCION 21h.
ESTE ES UN PROGRAMA QUE FORMA PARTE DE LAS
RUTINAS DEL SISTEMA OPERATIVO TIENE MUCHAS
,
OPCIONES PARA ELEGIR, LA CUAL SE DECIDE EN BASE
AL CONTENIDO DEL REGISTRO ACUMULADOR
1
FIN
Figura 4. Diagrama de Flujo del ejemplo.
En la tabla 2 aparece el código fuente escrito en lenguaje ensamblador. Por favor lea el
código fuente y luego, apoyándose en el flujo-grama y los abundantes comentarios,
compare la estructura del código en ensamblador con el de lenguaje C, estableciendo
similitudes y diferencias.

5. Microprocesadores C0112.
PROGRAMA EN LENGUAJE ENSAMBLADOR
include IO_BAS.INC ;Indica al compilador que incluya la librería respectiva.
;El archivo IO_bas.INC debe estar almacenado en
;la carpeta inc del emulador
.model small ;Indica al compilador el modelo de memoria que se usara
;en este caso se usa un modelo pequeno
;=====================================================
;ZONA PARA DECLARAR LAS VARIABLE Y CONSTANTES DEL PROGRAMA
;
;SE LE CONOCE COMO SEGMENTO DE DATOS
;
;Inicia con la directiva simplificada .data
;=====================================================
.data
frase db 'HOLA MUNDO',0Ah,0Dh,'$' ;Declara cadena que se va a imprimir
pak db 'Presione cualquier tecla para terminar el programa$'
;===========================================================
;ZONA PARA ESCRIBIR LAS INSTRUCCIONES, MACRO-INSTRUCCIONES
;Y PROCDIMIENTOS QUE SE EJECUTARAN.
;
;SE LE CONOCE COMO SEGMENTO DE CODIGO
;
;Inicia con la directiva simplificada .code
;==========================================================
.code
INICIO:
mov ax, @DATA ;Bloque de instrucciones que ubica la zona de
;memoria donde estan almacenados los datos
;con los que el programa va a trabajar.
;Se utiliza la instruccion MOV (mover) para
;trasladar al registro AX la direccion de memoria
;donde inicia este bloque
mov ds, ax ;Transfiere (en realidad copia) el contenido del
;registro AX al registro DS
Imprimir_Cadena frase ;Macro-Instruccion que imprime la cadena llamada frase
Imprimir_Cadena pak ;Macro-Instruccion que imprime la cadena llamada fin
Presione_Tecla_Fin ;Macro-Instruccion que espera a que se
;presione cualquier tecla para seguir adelante
FIN:
mov ax, 4C00h ;Bloque de instrucciones que terminan el programa
int 21h
;==========================================================
;ZONA DE MEMORIA DONDE SE ALMACENAN DATOS INTERMEDIOS QUE SE CREAN
;DURANTE LA EJECUCION DEL PROGRAMA.
;
;SE LE CONOCE COMO SEGMENTO DE PILA
;
; Inicia con la directiva simplificada .stack
;==========================================================
.stack
end INICIO
Tabla 2. Programa en lenguaje ensamblador.

6. 6 Microprocesadores C0112.
Siguiendo el mismo planteamiento del código de C, se puede dividir el código en
ensamblador en las siguientes partes:
a) Directivas de preproceso: Le indican al compilador que debe tomar información
de los archivos de biblioteca durante el proceso de convertir el archivo ASM en
EXE.
b) Declaración del Segmento de Datos: Donde se declaran las variables y
constantes que el programa va a utilizar.
c) Declaración del Segmento de Código: Donde se define las acciones que el
programa deberá realizar. Para especificarlo se pueden usar: Instrucciones
(propias del microprocesador), Macro-instrucciones (similar a los comandos de
los lenguajes de alto nivel), Procedimientos (similar a las funciones definidas
por el usuario de los lenguajes de alto nivel) y llamado a Interrupciones, que es
una forma muy particular del lenguaje ensamblador y que se explicara a su
debido tiempo.
d) Declaración del Segmento de PILA o STACK: bloque de memoria donde
almacenan datos intermedios que se generan durante la ejecución de un
programa. En este no se declaran variables o constantes como en el segmento
de datos, sino que se administra como una memoria LIFO, el último en entrar
es el primero en salir.
e) Directiva END: que indica el fin del archivo, cualquier instrucción posterior a
esta línea será ignorada por el compilador.
COMPILADO Y EJECUCION.
Si ya se tiene un código fuente escrito en lenguaje ensamblador (con extensión ASM y
cuyo nombre no debería exceder los 8 caracteres) se debe proceder a transformarlo en
un archivo ejecutable, en este caso tipo EXE, esto se logra presionando el botón
“compile” del IDE (ver figura 3). Hay que recordar que el proceso para convertir un
ASM en EXE es complejo e implica muchos pasos que en un buen programador no
debería ignorar y que en su momento se explicarán durante el curso.
Mientras se realiza la transformación (en el caso muy particular del EMU8086) se abre
un ventana llamada “assembler status” que le informa sobre los resultados del
proceso. Si existe algún error ahí se le hará notar, de lo contrario se observa un
mensaje como el de la figura 5.
A continuación se pide asignar un nombre al archivo EXE, por defecto se le asigna el
mismo nombre del archivo fuente, pero usted puede elegir otro, siempre de 8
caracteres máximo.
Volviendo a la figura 5, en el caso de no tener errores, la ventana “assembler status”
muestra diferentes opciones como ejecutar el archivo EXE dentro del programa (opción
run), revisar algunos de los archivos complementarios que se crearon en el proceso
(opción view), o ejecutar el archivo usando el programa DEBUG (opción external), ésta
es otra herramienta que se estudiará más adelante en el curso, la última opción es
cerrar la ventana (close).

7. Microprocesadores C0112.
Si ya tiene un archivo EXE que fue previamente compilado puede ejecutarlo dentro del
EMU8086 presionando el botón “emulate” del IDE, con lo que se abren dos ventanas
más, aparte del IDE que ya estaba abierto, a estas se les llama “emulator” y “original
source code” como se muestra en la Figura 6.
Figura 5. Estado del proceso de compilación.
Figura 6. Ventanas del EMU8086: emulador, código fuente e IDE.

8. 8 Microprocesadores C0112.
En la ventana “emulator” se puede monitorear la mayoría de procesos al ejecutar el
programa y es la que más se usará a la hora de realizar las prácticas de laboratorio,
por lo que es importante su manejo efectivo. Una vista más detallada se presenta en la
Figura 7.
Dada la gran importancia que tiene la ventana “emulator” es necesario analizarla más
detenidamente, está dividida en varias partes:
Figura 7. Ventana del Emulador.
Parte superior: tiene una barra de herramientas con las siguientes opciones:
 File, permite administrar (cargar o salvar) los archivos que va creando o
ejecutando
 Math, da acceso a una calculadora y un convertidor de basas de numeración.
 Debug, provee herramientas para depurar programas.
 View, permite abrir otras ventanas que pueden ser de mucha ayuda al ejecutar
o depurar programas.
 External, permite ejecutar el programa con otras herramientas diferentes del
EMU8086.
 Virtual devices, activa los dispositivos virtuales con que cuenta el programa,
dado que se tata de un emulador no se tiene acceso a los puertos físicos de la
computadora, por lo que estos son simulados.
 Virtual drive, da opciones para administrar las unidades virtuales de
almacenamiento (HDD y FDD virtuales).
 Help, activa la herramienta de ayuda.

9. Microprocesadores C0112.
Bajo la barra de herramientas hay cinco botones que le permiten:
 Load, carga un archivo ejecutable EXE, COM, etc. que ya existe.
 Reload, recarga (inicializa los registros) para ejecutar nuevamente un programa
que acaba de ser corrido.
 Single step, ejecuta solamente una instrucción o macroinstrucción (paso a
paso).
 Step back, retrocede una instrucción que ya fue ejecutada (función muy útil al
depurar un programa)
 Run, ejecuta un programa en su totalidad o hasta presionar el botón “STOP”.
Vale la pena hacer notar que también es posible, en la opción DEBUG, insertar
un “break point” cuando se está depurando programas.
Parte media: está dividida en tres áreas:
 Área izquierda denominada “registers”, donde se puede monitorear el contenido
de los registros del microprocesador
 Área central, donde se puede observar el contenido de la memoria desde donde
se está ejecutando el programa. Primero se notan las direcciones del bloque de
memoria que se visualiza, estas direcciones de dan en un formato llamado físico
o absoluto (existe otro formato para las direcciones) dado por cinco cifras
hexadecimales (20 bits) lo que indica que en este bus de direcciones se puede
direccionar desde la dirección 00000h (dirección 0) hasta la dirección FFFFFh
(dirección 1048575). Luego se indica el contenido de cada palabra (cada una de
1 byte), por facilidad el contenido se presenta en hexadecimal, decimal e
interpretado como un carácter ASCII.
 Área derecha, donde puede observar el contenido de la memoria, pero esta vez
no se detalla con direcciones específicas, sino que cada bloque de datos es
interpretado como un conjunto de instrucciones (lo que se llama PROGRAMA
DESENSAMBLADO) que el microprocesador deberá ejecutar. Es importante
mencionar que algunas instrucciones se expresan solo con un byte, pero otras
necesitan varios bytes para ser expresadas.
Parte inferior: contiene una serie de botones que permiten un acceso rápido a una
serie de ventanas auxiliares, algunas de las cuales se puede activar también en la
barra de herramientas con la opción “view”
La otra ventana llamada “original source code” muestra el código fuente del archivo,
esta ventana tiene algunas semejanzas con la ventana del IDE (donde se escriben los
códigos fuentes), pero tiene un objetivo diferente. Si observa detenidamente la Figura
8 notará que “original source code” no posee botones y que aparece resaltada la línea:
mov ax, @DATA
Eso indica que al comenzar a correr el programa, ésta será la primera instrucción que
se ejecutará.
Con esta ventana podrá monitorear el código línea a línea, al ejecutar paso a paso, así
como le permitirá ubicar en la memoria bloques completos del programa, pero ahí no
puede editar el código, para eso está el IDE.

10. 10 Microprocesadores C0112.
Figura 8. Comparación entre las ventanas de edición y código fuente.
Otra de las ventanas muy útiles del EMU8086 es la ventana de variables “variables”, le
permitirá monitorear las variables declaradas en tiempo real. Para activarla debe
ubicar el botón “vars” en la ventana “emulator” (ver figura 7).
La ventana tiene un aspecto como el que se muestra en la figura 9.
Figura 9. Ventana auxiliar para monitorear el contenido de las variables declaradas.