UNIDAD CENTRAL DE PROCESAMIENTO (CPU)

UNIDAD 3 – FASE 4
ACTIVIDAD INDIVIDUAL

Presentado por:
FABIÁN ESTEBAN LUNA ÁLVAREZ – CODIGO: 1.042.706.636

DIRECTOR:
ANYELO GERLEY QUINTERO

GRUPO 27

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA

FACULTAD DE INGENIERIA DE SISTEMAS
ARQUITECTURA DE COMPUTADORES
MAYO 2017
 INTRODUCCIÓN

El desarrollo de esta actividad requiere que el estudiante lea la documentación que se

encuentra en el curso de arquitectura de computadores. En la actividad se debe dar solución
a dos ejercicios en lenguaje ensamblador por medio de programa emu8086, también se
debe dar respuesta con un gráfico a las instrucciones tipo de salto en ensamblador.
 OBJETIVOS

❖ Desarrollar programas en lenguaje ensamblador.

❖ Adquirir el conocimiento de cuáles son las instrucciones tipo de salto en el lenguaje

ensamblador.

❖ Adquirir conocimientos de cómo utilizar las instrucciones del lenguaje

ensamblador.
 DESARRROLLO DE LA ACTIVIDAD
1. Explicar mediante un gráfico en que consiste las instrucciones tipo salto del lenguaje ensamblador (Direcciones cortas,
cercanas y lejanas, etiquetas, saltos incondicionales, saltos condicionales, instrucciones de testeo, decisiones y bucles).
2. Desarrollar un código en lenguaje ensamblador que permita leer un número de un digito
por teclado y determinar si el número es par, impar o cero. Generar tres capturas por pantalla
de la ejecución del programa. Anexar Archivo .asm del programa. Nota: No utilizar
Simuproc.
.MODEL SMALL
.STACK 64
.DATA

ESPACIO DB 13,10,"$"
LECTURA DB 13,10,"PROGRAMA QUE CONSISTE EN LEER UN NUMERO DE UN DIGITO POR TECLADO","$"
LECTURA1 DB 13,10,"Y EVALUAR SI EL NUMERO INGRESADO ES: PAR, IMPAR O CERO","$"
LECTURA2 DB 13,10,"TRABAJO REALIZADO POR FABIAN ESTEBAN LUNA ALVAREZ"
LECTURA3 DB 13,10,"CODIGO: 1.042.706.636","$"
LECTURA4 DB 13,10,"UNAD","$"
LECTURA5 DB 13,10,"2017","$"
MENSAJE DB 13,10,"DIGITAR NUMERO DE UN SOLO DIGITO: ","$"
MEN_PAR DB 13,10,"EL NUMERO INGRESADO ES PAR","$"
MEN_IMPAR DB 13,10,"EL NUMERO INGRESADO ES IMPAR","$"
MEN_CERO DB 13,10,"EL NUMERO INGRESADO ES CERO","$"
ESPACIO1 DB 13,10,"","$"
VALOR DB 0
NUM DB 2

.CODE
.STARTUP

MOV AX, @DATA

MOV AH,09H
LEA DX,ESPACIO
INT 21H
MOV AH,09H
LEA DX,LECTURA
INT 21H
MOV AH,09H
MOV AH,LECTURA1
INT 21H
MOV AH,09H
LEA DX,LECTURA2
INT 21H
MOV AH,09H
MOV AH,LECTURA3
INT 21H
MOV AH,09H
LEA DX,LECTURA4

INT 21H
MOV AH,09H
LEA DX, LECTURA5
INT 21H
MOV AH,09H
LEA DX,ESPACIO
INT 21H
MOV AH,09H
LEA DX, MENSAJE
INT 21H
CALL LEER
SUB AL,30H
MOV VALOR,AL
MOV AH,09H
LEA DX,ESPACIO
INT 21H
MOV BL,VALOR
CMP BL,0
JE CERO
INT 21H
XOR AX,AX
MOV AL,NUM
MOV BL,AL
MOV AL,VALOR
DIV BL
CMP AH,0
JZ PAR
JMP IMPAR

;PROCEDIMIENTOS
LEER PROC NEAR
MOV AH,01H
INT 21H
RET
CERO:
MOV AH,09H
LEA DX,MEN_CERO
INT 21H

JMP SALIR
PAR:
MOV AH,09H
LEA DX, MEN_PAR
INT 21H
JMP SALIR

IMPAR:
MOV AH,09H
LEA DX,MEN_IMPAR
INT 21H
JMP SALIR

SALIR:
MOV AX,4C00H
INT 21H
END
3. Desarrollar un código en lenguaje ensamblador que permita realizar una multiplicación de
dos números a través de sumas sucesivas y una potencia a través de multiplicaciones
sucesivas (para ello debe utilizar instrucciones tipo bucle). Al inicio del programa se deben
capturar por teclado dos números de un digito cada uno; Generar tres capturas por pantalla
de la ejecución del programa. Anexar Archivo .asm del programa. Nota: No utilizar Simuproc
include "emu8086.inc"
.model small
.stack
.data

mj1 db 10,13,"EJERCICIO DE SUMA, MULTIPLICACION Y POTENCIA: ","$"

mj2 db 10,13,10,13,"INGRESE EL NUMERO 1: ","$"
mj3 db 10,13,"INGRESE EL NUMERO 2: ","$"
mj4 db 10,13,"RESULTADO DE MULTIPLICACION: ","$"
mj5 db 10,13,"RESULTADO DE LA POTENCIACION: ","$"

var1 db 0
var2 db 0
potencia db 1
diez dw 10

.code

inicio:
mov dx,@data
mov ds,dx
xor ax,ax
xor bx,bx
xor cx,cx
mov var1,0
mov var2,0

mov ah,09h
lea dx,mj2
int 21h

mov ah,01h
int 21h
sub al,30h
mov var1,al

mov ah,09h
lea dx,mj3
int 21h

mov ah, 01h

int 21h
sub al,30h
mov var2,al

cmp var2,0
 jz sr
mov cl,var2

Multi:
add bl,var1
loop Multi

sr:
mov ah,09h
lea dx,mj4
int 21h

mov ax,bx
call PRINT_NUM

mov ah,09h
lea dx,mj5
int 21h

xor ax,ax
xor bx,bx
xor cx,cx

mov al,potencia
cmp var2,0
jz sh

mov cl,var2

Pot:
mul var1
loop pot

sh:

call PRINT_NUM
jmp inicio

PRINT_NUM Proc NEAR

push dx
push ax
cmp ax,0
jnz not_zero
PUTC "0"
jmp printed

not_zero:

cmp ax,0
jns positive
neg ax

PUTC "-"
positive:
call PRINT_NUM_UNS
printed:pop ax
pop dx
ret
PRINT_NUM endp

PRINT_NUM_UNS proc NEAR

push ax
push bx
push cx
push dx

mov cx,1
mov bx,10000

cmp ax,0

begin_print:

cmp bx,0
jz end_print

cmp cx,0
je calc
cmp ax,bx
jb skip

calc: mov cx,0

mov dx,0
div bx

add al,30h
putc al
mov ax,dx

skip:
push ax
mov dx,0
mov ax,bx
div diez
mov bx,ax
pop ax

jmp begin_print

putc "0"

end_print:
pop dx
pop cx
pop bx
pop ax

ret
PRINT_NUM_UNS endp
end
 CONCLUSIONES

❖ Por medio de las consultas realizadas se adquiere el conocimiento necesario para el

desarrollo de los dos ejercicios en lenguaje ensamblador.

❖ La investigación de los conceptos del lenguaje ensamblador, nos da a conocer los

tipos de salto, los bucles, decisiones, etiquetas que se utilizan en el código.
 BIBLIOGRAFÍA

Dragonjar. (16 de 01 de 2016). Dragonjar. Obtenido de

http://comunidad.dragonjar.org/f177/tutorial-completo-de-lenguaje-ensamblador-8845

Hurtado, A. V. (15 de 11 de 2016). http://www.abreojosensamblador.net. Obtenido

dehttp://www.abreojosensamblador.net/Productos/AOE/html/Pags/Contenidos.html