Año de la consolidación del Mar de Grau

Facultad de Ingeniería de Producción y

Servicios
Escuela profesional de Ingeniería Electrónica.

Curso: Arquitectura de Computadoras

Turno: “A”, Martes 7.00 – 9.00 am
Grupo:

Programas en EMU Y DEBUG

ORDENAMIENTO DE 12 NUMEROS
SUMA Y PROMEDIO DE 12 NUMEROS

Docente: Ing. Erasmo Sulla Espinoza

Alumnos:
Coaquira Caytuiro, Elvis Renán CUI: 20104208
Sinticala Mamani, Esteban René CUI: 20103349
Ticona Olazabal, Renzo Alberto CUI: 20103197

Arequipa 08 de Junio del 2016

Contenido
Usando el DEBUG .......................................................................................................................... 2
Programa de suma y promedio en Debug: ................................................................................... 4
Programa de suma y promedio en EMU8086: .............................................................................. 8
Programa de ordenamiento en DEBUG ...................................................................................... 10
Ordenamiento de 12 números en EMU8086 .............................................................................. 13
Bibliografía: ................................................................................................................................. 15

1
Usando el DEBUG
Usamos máquina virtual con Windows XP o usamos el programa DOSbox que está en el CD del
curso.
En este caso usamos el programa DOSbox, para ello hay que seguir los siguientes pasos:
1) Instalar el programa:

2
2) Obtener el archivo Debug.exe, en este caso lo obtuvimos de una máquina virtual con
Windows XP, también puede ser descargado de internet.

La ruta del archivo debug.exe en Windows XP es:

C:\WINDOWS\system32\debug.exe

3) copiar el archivo debug.exe a un directorio en nuestra PC, en este caso lo pusimos en la

unidad D.

4) Ahora que ya tenemos el archivo debug.exe en la PC, debemos ejecutarlo, para ello
arrancamos el DOSbox.

Para iniciar el debug, debemos primero cargarlo.

Para esto tenemos que introducir las siguientes instrucciones en la consola desplegada

3
-mount D: D:\ ; aquí estamos montando la unidad D de nuestro disco duro
-D: ; con esto estamos dando como carpeta de trabajo al disco D
-debug ; como copiamos el archivo Debug en el disco D y con las anteriores
instrucciones nos encontramos trabajando en este directorio, solo
queda ejecutarlo.

Programa de suma y promedio en Debug:

C. Programa, codificación lenguaje máquina, suma, promedio 12 números
(8,2,2,6,7,4,3,1,5,7,8,2) usando bucles, inicio de dirección de datos [200]

Código a usar:
cargar_numeros: (al ser debug, los números fueron cargados previamente
con el comando –e [memoria] [valor])

suma:
MOV BX,0200h ;asigna registro base a 100h
MOV CX,0Ch ;asigna contador CX a N, en este caso 9
PUSH cx
XOR AX,AX ;limpia el AX
CLC ;limpia el flag de acarreo
lazo:
ADD DL,[BX+SI] ;coge la base y la suma con DL, almacenando
resultado en DL
ADC AX,DX ;coge DX (DL) y lo suma con acarreo en el AX
XOR DX,DX ;limpia DX para un sgte loop, el AX es donde se
almacena la suma
INC SI ; incrementa el SI
LOOP lazo ;decrementa CX y salta a lazo, si CX llega a 0
con el decremento, entonces sale del bucle
MOV [BX+0C],AL ;almacena suma en 0209 (BX+09)
POP cx
DIV cx
mov [BX+0D],AL ;Almacena cociente en 020A
mov [BX+0E],DX ;Almacena residuo en 020B

4
Desarrollo:
1) Primero cargamos los números a memoria:
Para ello usamos el comando e del debug.

Podemos corroborar que está bien hecho usando el comando d [dirección]

En este caso –d 200 (ver la memoria a partir de la dirección 200)

2) Ahora usamos el comando a para empezar a escribir nuestro código.

5
Para finalizar la escritura del código, apretamos enter una vez al final sin escribir ninguna
instrucción
3) Ahora vamos a ejecutar nuestro programa
Para ello usamos el comando t [=xxxx:xxxx] donde xxxx:xxxx es la direccion de inicio de las
instrucciones del código
En nuestro caso es 0769:0100

6
Podemos ir viendo como AX va incrementando en cada bucle, ya que es allí donde se almacena
la suma de los números, cuando se hayan terminado las 12 sumas, AX tendrá el valor de 37h
(verde), CX el valor de 0h (Rojo) y SI el valor de 0Ch (Azul)

Al finalizar, el programa, usaremos D 200 para volver a revisar los valores de las memorias,
recordemos que la suma debe estar en 020Ch (verde), el cociente (promedio) debe estar en
020Dh (rojo), y el resto de dicha división debe estar en 020Eh (azul).

Con esto habríamos probado con éxito el programa de suma y promedio de 12 números.

7
Programa de suma y promedio en EMU8086:
Codigo a usar:
cargar_numeros:
MOV [0100h],08h
MOV [0101h],02h
MOV [0102h],02h
MOV [0103h],06h
MOV [0104h],07h
MOV [0105h],04h
MOV [0106h],03h
MOV [0107h],01h
MOV [0108h],05h
MOV [0109h],07h
MOV [010Ah],08h
MOV [010Bh],02h
suma:
MOV BX,0100h ;asigna registro base a 100h
MOV CX,0Ch ;asigna contador CX a N, en este caso 0Ch
(12 en decimal)
push cx
XOR AX,AX ;limpia el AX
CLC ;limpia el flag de acarreo
lazo:
ADD DL,[BX+SI] ;coge la base y la suma con DL,
almacenando resultado en DL
ADC AX,DX ;coge DX (DL) y lo suma con acarreo en el
AX
XOR DX,DX ;limpia DX para un sgte loop, el AX es
donde se almacena la suma
INC SI ;incrementa el SI
LOOP lazo ;decrementa CX y salta a lazo
mov [010Ch],AX ;almacena suma en 010C
pop cx
div cx
mov [010Dh],AL ;almacena el cociente (promedio) en 010D
mov [010Eh],DX ;almacena el resto en 010E

Desarrollo:
Introducimos el código en el emu8086:

8
Procedemos a ejecutar el programa, abriremos el visor de memoria para poder ver los números,
cargados y los resultados de suma y promedio:

Con lo que nos quedaría lo siguiente:

Resaltado se encuentra el lugar donde se pone la memoria a revisar, en este caso ponemos
100:100 para checar las memorias que hemos asignado al inicio (los números a sumar)

Ejecutamos el programa con run y observamos las memorias:

Como podemos observar, obtenemos los mismos resultados que obtuvimos con el debug, por
lo que queda demostrado el funcionamiento del código para suma y promedio de 12 números,
con bucle.

9
Programa de ordenamiento en DEBUG
E. Programa, codificación lenguaje máquina, ordenamiento de 12 números
(8,2,2,6,7,4,3,1,5,7,8,2) usando bucles, inicio de dirección de datos [200]
Código a usar:

cargar_numeros: (al ser debug, los números fueron cargados previamente

con el comando –e [memoria] [valor])

MOV BX,0200h ;define registro base para trabajar luego con

el SI y con desplazamientos de 2
MOV CX,0Ch ;carga el 12(0C)en CX que sera nuestro contador
lazo1:
PUSH CX ;poner encima en la pila
MOV CX,0Bh ;reducir en uno el acumulador y ponerlo
nuevamente en cx
MOV AX,[BX] ;contenido de BX enviado a AX
XOR SI,SI ;limpia el indice de pila, osea lo pone en 0
psss

Lazo2:
CMP AX,[BX+SI+2] ;compara el primero osea AX contra [BX+SI+2] y
se setea flag correspondiente
JA No_cambia ;salta a etiqueta No_cambia si la comparativa
sale mayor o igual (en debug seria 011B)
PUSH [BX+SI+2] ;almacena en la pila el valor de memoria BX
desplazado en 2
MOV [BX+SI+2],AX ;pone el valor de AX en el base BX + el índice
SI desplazado en 2, este es el ordenamiento
POP [BX+SI] ;este recupera el valor que fue almacenado en
pila en la memoria anterior, este es el
ordenamiento

No_cambia:
ADD SI,2 ;como es mayor, entonces no hay que hacer
nada... entoncs pasamos el siguiente
agregandole 2 al indice
MOV AX,[BX+SI] ;estamos poniendo el nuevo numero al AX para
compararlo denuevo
LOOP lazo2 ;saltamos a lazo 2 para comparar (en debug
010E)
POP CX ;coje valor de pila y lo retorna al CX
LOOP lazo1 ;salta a lazo 1 y decrementa cx (en debug 0106)

Desarrollo:
1) Primero cargamos los números a memoria:
Para ello usamos el comando e del debug.

10
Podemos corroborar que está bien hecho usando el comando d [dirección]
En este caso –d 200 (ver la memoria a partir de la dirección 200)

2) Ahora usamos el comando a para empezar a escribir nuestro código.

3) Ahora vamos a ejecutar nuestro programa

Para ello usamos el comando t [=xxxx:xxxx] donde xxxx:xxxx es la dirección de inicio de las
instrucciones del código
En nuestro caso es 0769:0100

11
Se hará un barrido una y otra vez para encontrar valores menores a la izquierda de un valor
mayor, en caso suceda, se hará un intercambio de valores.

Avanzaremos hasta el final del programa, el cual nos debe dar como resultado la secuencia
887765432221

Podemos observar que la secuencia ha sido ordenada, por lo que queda demostrado la
funcionabilidad de este programa mediante la herramienta debug.

12
Ordenamiento de 12 números en EMU8086
Código a usar:
setea_numeros:
MOV [0100h],08h
MOV [0102h],02h
MOV [0104h],02h
MOV [0106h],06h
MOV [0108h],07h
MOV [010Ah],04h
MOV [010Ch],03h
MOV [010Eh],01h
MOV [0110h],05h
MOV [0112h],07h
MOV [0114h],08h
MOV [0116h],02h

MOV BX,0100h ;define registro base para trabajar luego

con el SI y con desplazamientos de 2
MOV CX,0Ch ;carga el 12(0C)en CX que sera nuestro
contador
lazo1:
PUSH CX ;poner encima en la pila
MOV CX,0Bh ;reducir en uno el acumulador y ponerlo
nuevamente en cx
MOV AX,[BX] ;contenido de BX enviado a AX
XOR SI,SI ;limpia el indice de pila, osea lo pone en
0 psss

Lazo2:
CMP AX,[BX+SI+2] ;compara el primero osea AX contra
[BX+SI+2] y se setea flag correspondiente
JA No_cambia ;salta a etiqueta No_cambia si la
comparativa sale mayor o igual (en debug
seria 011B)
PUSH [BX+SI+2] ;almacena en la pila el valor de memoria
BX desplazado en 2
MOV [BX+SI+2],AX ;pone el valor de AX en el base BX + el
índice SI desplazado en 2, este es el
ordenamiento
POP [BX+SI] ;este recupera el valor que fue almacenado
en pila en la memoria anterior, este es el
ordenamiento

No_cambia:
ADD SI,2 ;como es mayor, entonces no hay que hacer
nada... entoncs pasamos el siguiente
agregandole 2 al indice
MOV AX,[BX+SI] ;estamos poniendo el nuevo numero al AX
para compararlo denuevo

13
LOOP lazo2 ;saltamos a lazo 2 para comparar (en debug
010E)
POP CX ;coje valor de pila y lo retorna al CX
LOOP lazo1 ;salta a lazo 1 y decrementa cx (en debug
0106)

Al igual que con la suma y promedio, copiamos nuestro código al emu y habilitamos la vista de
la memoria para poder observar el funcionamiento del código:

En este caso copiaremos el código y ejecutaremos paso a paso hasta la carga de valores en
memoria, para poder ver el estado inicial de los números y luego poder ver como quedan los
números ordenados.

Podemos ver que la secuencia original es 8, 2, 2, 6, 7, 4, 3, 1, 5, 7, 8, 2

Ahora terminaremos de ejecutar el programa:

14
Podemos ver subrayado en verde en la parte de abajo que la secuencia hora esta ordenada,
siendo 8, 8, 7, 7, 6, 5, 4, 3, 2, 2, 2, 1

El resultado es el mismo que con el debug, por tanto queda demostrado que el código utilizado
funciona y nos permite realizar el ordenamiento de 12 números.

Bibliografía:
Maicol Blas - https://www.youtube.com/watch?v=CESBFuP5aHw
Maicol Blas - https://www.youtube.com/watch?v=3GVV8ncgeVU
http://kipirvine.com/asm/debug/debug_tutorial.pdf

15