Documente Academic
Documente Profesional
Documente Cultură
CÓDIGO: 301302
Ciclo de la Tarea 3
Lenguaje de máquina Ensamblador - Formato de las instrucciones
Presentado a:
Anyelo Gerley
Entregado por:
Grupo: 301302A_611
OBJETIVOS
Traducir lenguaje ensamblador a lenguaje de maquina
Conocimiento de registros
Conocer formato de instrucciones
Conocer comportamiento de bucles
Conocer como es el control directo de hardware mediante instrucciones de assembler
Actividades a desarrollar
1 Explicar mediante una infografía en que consiste las instrucciones tipo salto del Lenguaje
Ensamblador (Direcciones corta, cercana y lejana, etiquetas, saltos incondicionales, saltos
condicionales, instrucciones de testeo, decisiones y bucles). Cada instrucción debe tener una
definición y 1 ejemplo en lenguaje ensamblador. NO se aceptan enlaces de ningún tipo, todo
debe ser subido mediante un documento al foro.
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. Documentar perfectamente todo el
código. Generar tres capturas por pantalla de la ejecución del programa. Anexar Archivo .asm
del programa
; Nombre del Autor: JOHN YARA
; Código : 79512473
; Grupo No : 301302A_611
;Fecha : 20-04-2019
.model small ; define el tipo de memoria que se utilizara
.stack 64 ; es para darle el grandor a la pila
.data
.code
; limpiar pantalla
mov ah, 00
mov al, 03h
int 10h
mov ah,01h
int 21h
sub al, 30h; para convertir en ascii y visualizarlo
mov var1, al
int 21h
sub al, 30h
mov ah, var1
cmp bl,1
JP PAR ; si es par
JNP IMPAR; si es impar
Jz CERO ; es cero
Arquitectura par-impar.asm
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. Documentar perfectamente todo el código. Generar
tres capturas por pantalla de la ejecución del programa. Anexar Archivo .asm del programa
;------------------------------------------------------------------------------------
; Nombre del Autor: John Jairo Yara O
; Código: 79512473
; Grupo No: 301302A_611
;Fecha: 19-04-2019
; 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
;------------------------------------------------------------------------------------
.code : programa
inicio:
mov ah,09
lea dx, msj1
int 21h
mov ah,01h
lea dx, msj3 ; mensaje ingrese primer numero
int 21h
sub al,30h
mov var1,al
mov ah,09
lea dx, msj2
int 21h
mov ah,01h
int 21h
sub al,30h
mov var2,al
cmp var2,0
jz sr
mov cl,var2
mov ah,09
lea dx, msj3
int 21h
mov ax,bx
call PRINT_NUM
mov ah,09
lea dx, msj4
int 21h
xor ax,ax ;deja regsitro enc eros para continuar con operacion
xor bx,bx
xor cx,cx
mov cl,var2
Pot:
mul var1
loop Pot
sh:
call PRINT_NUM
jmp inicio ; vuelve al inicio de programa solicita valores se repetite como bucle
PUSH DX
PUSH AX ; guarda residuo
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 ; devuelve valor que tenia AX
POP DX
RET
PRINT_NUM ENDP
;PRINT_NUM_UNS NEAR
PUSH AX
PUSH BX
PUSH CX
PUSH DX
MOV CX,1
CMP BX,0
;JZ print_zero
begin_print:
CMP CX,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
;print_zero:
;PUTC '0'
end_print:
POP DX
POP CX
POP BX
POP AX
RET
;PRINT_NUM_UNS ENDP
end
CODIGO FUENTE:
Conclusiones
Se profundiza en el uso de instrucciones que contienen las órdenes a seguir para llevar a cabo
una acción. Asimismo como estas órdenes mediante variables y uso de emul8086 permite
cargarlas en memoria teniendo claro el comportamiento final de las órdenes escritas en
lenguaje assembler
REFERENCIAS BIBLIOGRÁFICAS