Instituto Tecnológico de Acapulco

Ingeniería en Sistemas Computacionales

= LENGUAJE DE INTERFAZ =

Practica N° 3.-
CODIGO GRAY
EXCESO 3
RESTA SUMANDO
PARIDAD IMPAR

Integrantes del Equipo:

Mariana Del Sol Castillo Domínguez
Alonso Salado Salas
José Carlos gallegos gandarilla
Daniel Martínez vinalay
Carlos Antonio Ramírez Fabián

Horario: 12:00 a 13:00 pm Ciclo escolar: agosto-dic

 INDICE

Tabla de contenido
MARCO TEÓRICO.............................................................................Error! Bookmark not defined.
Emulador EMU8086 .......................................................................Error! Bookmark not defined.
DESARROLLO ...................................................................................Error! Bookmark not defined.
.......................................................................................................Error! Bookmark not defined.
PRUEBAS Y ANÁLISIS DE RESULTADOS ..................................Error! Bookmark not defined.
INTRODUCCIÓN

El lenguaje ensamblador como cualquier lenguaje de programación es un conjunto

de palabras que le indican al ordenador lo que tiene que hacer. Sin embargo la
diferencia fundamental es que cada instrucción escrita en lenguaje ensamblador
tiene una correspondencia exacta con una operación en el procesador. Por lo que
son operaciones muy sencillas tales como: “Cargar 32 en el registro BX” o
“Transferir el contenido del registro CL al CH”. Así pues, las palabras del lenguaje
ensamblador son nemotécnicos (sistemas sencillos utilizados para recordar una
secuencia de datos, nombres, números, y en general para recordar listas de items
que no pueden recordarse fácilmente) que representan el código máquina, lenguaje
que entiende el procesador.
El código binario reflejado o código Gray, nombrado así en honor del
investigador Frank Gray, es un sistema de numeración binario en el que dos
números consecutivos difieren solamente en uno de sus dígitos. El código Gray
fue diseñado originalmente para prevenir señales ilegales (señales falsas o
viciadas en la representación) de los switcheselectromecánicos, y actualmente es
usado para facilitar la corrección de errores.
El código binario Exceso-3, (normalmente abreviado como XS-3 o X323) es un
código decimal codificado en binario auto complementario y un sistema de
numeración. Es una representación parcial. Exceso-3 fue utilizado en
varias computadoras antiguas.
Un bit de paridad es un dígito binario que indica si el número de bits con un valor
de 1 en un conjunto de bits es par o impar. Los bits de paridad conforman el
método de detección de errores más simple.
DESARROLLO

Para iniciar se debe ejecutar el archivos EMU886.exe, que se encuentra en la

carpeta del mismo nombre, en el directorio raíz; seguramente en la computadora
donde corra el programa observará primero la pantalla de Bienvenida (welcome),
similar a la que se muestra en la Figura.
Para continuar este primer contacto con el emulador seleccione New. Observará
una nueva caja de dialogo “choose code template”,como se muestra en la Figura.

En ella se le presentan seis opciones, cuatro que 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).

Dos que le permiten usar un espacio vacío “empty workspace” (sin una plantilla) o
activar el emulador mismo. Selecciones la opción del espacio vacío. Observará la
ventana de edición o mejor dicho el Entorno de Desarrollo Integrado (Integrated
Development Environme IDE), como se muestra en la Figura 3, donde escribirá sus
archivos fuentes en lenguaje ensamblador, por favor lo confunda con el lenguaje de
máquina.Podrá ver una barra de menú de Windows con sus opciones file, edit, etc.
pero también vera unas opciones poco usuales como assembler, emulator, etc.
propias del emulador.

También vera una serie de botones que le permitirán crear un nuevo archivo (new),
abrir un ejemplo (examples), compilar un archivo fuente (compile), emular un archivo
ejecutable (emulate).
En esta práctica 3 se hicieron 4 ejercicios en lenguaje ensamblador que son
código gray, exceso-3, paridad y resta sumando, cada una de las practicas
llevaban interrupciones diferentes vamos empezar con el de código gray
Donde lo primero que fue es declarar variables, y mostrar un mensaje en pantalla
que convirtiera un número del 0 al 9 decimal en código gray,
Comentamos cada instrucción para hacer más entendible el código y el programa

Ejecutamos el programa, al mostrarnos el mensaje podemos introducir cualquier

número del 0 al 9 decimal en este caso introducimos el 8 y automáticamente lo
convertirá en código gray como se muestra en la imagen.
EXCESO-3
Declaramos las variables, y mandamos un mensaje a pantalla cuando se ejecute
el programa, de convertir un número del 0 al 9 decimal en un exceso 3
Comentamos las instrucciones de nuestro código en base a nuestro manual 8086
de instrucciones

Ejecutamos el programa , donde nos mostrara en pantalla el mensaje de convierte

un numero del 0 al 9 decimal en exceso, donde podemos intruducir cualquier
numero que este del 0 al 9 en este caso introducimos el numero 9 , donde
automaticamente lo convirtio a exceso-3 binario
RESTA SUMANDO
En este programa lo que se hace es restar 2 numeros tanto minuendo y
sustrayendo , que al introducir ya sea un un minuendo mayor a sustrayendo nos
arrojara en pantalla el resultado negativo o si lo hacemos al reves el resultado
seria negativo .
En el codigo de instrucciones , primero declaramos el minuendo y sustrayendo,
donde asignamos un mensaje que nos mostrara en pantalla de ingresar el
minuendo y despues ingresar el sustrayendo.iniciams nuestro segmento de codigo
donde comentamos cada instrucción con etiquetas la funcionalidad de cada
instrucción.

Ejecutamos el programa, donde en la consola nos mostrara los mensajes que

introducimos en el codigo , donde introducimos un minuendo menor que fue 5 y un
sustrayendo mayor que fue 9 donde el resultado fue menos 4 pero el programa
nos dira si fue negativo o positivo que fue por efecto negativo , como se muestra
en la imagen.
PARIDAD
En este programa nos mostrara si el noveno es 1 o cero depende del tipo de
paridad que tenga el numero introducido , introduciremos un numero del 0 al 9
donde lo converitra en binario si ese numero por su numero de bits ees par su
noveno seria 1 por ejemplo el 5 tiene dos bits en 1 por lo tanto es par , eso indica
que su noveno numero sera 1. Como se muestra en pantalla

Código comentado
CONCLUSION

En conclusión el lenguaje ensamblador es más que un tipo de lenguaje de bajo

nivel en el cual es empleado para crear programas informáticos. Este lenguaje
es creado a base de instrucciones para intentar sustituir al lenguaje maquina
por uno similar utilizado por el hombre. La importancia de este es que en él se
pueden hacer cualquier tipo de programas que en otros lenguajes de alto nivel
no, al igual que ocupan menos espacio en la memoria, para hacer esta
práctica estos 4 ejercicios donde cada ejercicio como código gray, paridad,
exceso3 y resta sumando usan diferentes instrucciones para poder ejecutarse
pero al mismo tiempo iguales interrupciones como interrupción 21 que es muy
fundamental para estos 4 ejercicios que el profesor nos dejó realizar, para
cada ejercicio tenía un propósito por ejemplo el de paridad se tenía que ver si
el noveno numero era un uno o un cero depende de la paridad impar o par
que arrojaría como resultado al convertir el número que introdujéramos en
consola, el ejercicio de resta sumando se basó básicamente en el minuendo y
sustrayendo ya si introducíamos un minuendo menor al sustrayendo nos
arrojaría un resultado negativo y el programa nos diría si el resultado fue
negativo o positivo dependiendo los valores introducidos . En el ejercicio de
código gray al introducir un número del 0 al 9 ya sea cualquier valor que este
entre estos lo convertiría en código gray resuelve este problema cambiando
solamente un dígito a la vez. En el ejercicio de exceso 3 El número binario más
pequeño representa al valor más pequeño.

Es muy importante aprender lenguaje ensamblador y saber lo que significa

cada instrucción por eso debemos leer el manual de instrucciones 8086 porque
a un futuro en otras prácticas las estaremos ocupando y así se nos ira
facilitando al programar lenguaje ensamblador .