Ensamblador - PROBLEMA ENSAMBLADOR 8086

 
Vista:

PROBLEMA ENSAMBLADOR 8086

Publicado por benedyt (1 intervención) el 31/01/2011 20:20:42
Desarrollar un programa en ensamblador del 8086 en entorno MS-DOS que muestre en pantalla un
mensaje en el que se solicite una cadena binaria de 8 dígitos. A continuación, el programa se encargará
de calcular el valor equivalente de dicha representación binaria según los siguientes sistemas de
representación:
- Binario natural sin signo.
- Binario natural con signo.
- Complemento a 1.
- Complemento a 2.
- Decimal Codificado en Binario BCD.
- Hexadecimal.
ALGUIEN QUE ME AYUDE, POR FAVOR!!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

PROBLEMA ENSAMBLADOR 8086

Publicado por MSH (120 intervenciones) el 08/04/2011 00:00:57
Es una idea básica. Las mejoras a este programa ya van por cuenta de quien va a copiar este código

;-----------------------------------------------------------------------------------------------------------------------------------
;conversion de bases binarias, bcd y hexa

.model small

.stack 300h
;------------------------------------------------------
.data
CR equ 0dh
LF equ 0ah
salto db CR,LF,'$'
mens db 'Inserta numero de 8 bits',CR,LF,'$'
numero db 0h
numero2 db 0h
dos db 02h
multi db 128d

binarios label byte
string db 9
max db 9
cadena db 9 dup(' ')

uno db -01h
c2 db 01h

bcd1 db 0
bcd2 db 0
bcd3 db 0
aux db 0
nbcd db 0

h1 db 0
h2 db 0
hex db 16d
;-------------------------------------------------------
.code
inicio:

mov ax,@data
mov ds,ax
push ds
pop es
;-------------------------------------------------------
mov ah,09h ;rutina que obtiene cadena de 8 bits
lea dx,mens ;desde teclado
int 21h

mov ah,0ah
lea dx,binarios
int 21h

mov ah,09h
lea dx,salto
int 21h
;--------------------------------------------------------
xor si,si
lea si,cadena
mov cx,0008h
;--------------------------------------------------------
conver:
mov al,[si] ;convierte cadena a número
xor al,30h
mov bl,multi
mul bl
add al,numero
mov numero,al
mov numero2,al
mov nbcd,al
xor ax,ax
mov al,multi
div dos
mov multi,al
xor ax,ax
inc si
loop conver
call limpieza
;--------------------------------------------------------
; COMIENZAN LAS RUTINAS DE CONVERSION
;--------------------------------------------------------
;call imprimir ; muestra la cadena tal cual se tecleó
;mov ah,09h
;lea dx,salto
;int 21h
;call limpieza
;**************************************
mov al,numero
mov bl,-1
imul bl
mov numero,al ;rutina a numero negativo
call limpieza
call imprimir
mov ah,09h
lea dx,salto
int 21h
call limpieza
;**************************************
mov dl,numero2
mov numero,dl
not numero ;rutina complemento a 1
call limpieza
call imprimir
mov ah,09h
lea dx,salto
int 21h
call limpieza

;**************************************
mov al,numero2
not al
add al,01 ;rutina complemento a 2
mov numero,al
call imprimir
mov ah,09h
lea dx,salto
int 21h
call limpieza

;****************************************
mov al,nbcd ;rutina a BCD
mov bl,10
div bl
mov bcd1,ah
mov bcd2,al
call limpieza
mov al,bcd2
mov bl,10
div bl
mov bcd2,ah
mov bcd3,al
call limpieza

mov bl,bcd3
mov aux,bl
call print_bcd
call limpieza
mov dl,' '
call print
call limpieza

mov bl,bcd2
mov aux,bl
call print_bcd
call limpieza
mov dl,' '
call print
call limpieza

mov bl,bcd1
mov aux,bl
call print_bcd
call limpieza
mov dl,' '
call print
call limpieza
mov ah,09h
lea dx,salto
int 21h
call limpieza
nop
nop
nop

;**************************************
mov al,numero2 ;rutina en hexadecimal
div hex
mov h1,al
mov h2,ah
xor ax,ax

mov al,h1
cmp al,0ah
jae @diez
mov dl,al
or dl,30h
call print
jmp sigue
@diez:
add al,55
mov dl,al
call print
sigue:
mov al,h2
cmp al,0ah
jae @vein
mov dl,al
or dl,30h
call print
jmp fin
@vein:
add al,55
mov dl,al
call print
mov ah,09h
lea dx,salto
int 21h
call limpieza
nop
nop
nop



fin:
mov ax,4c00h
int 21h

;--------------------------------------------------------
imprimir proc near
mov cx,0008h ;ciclo para obtener el numero binario
mov al,numero
mov bl,dos
ciclo_bin:
div bl
push ax
mov numero,al
xor ax,ax
mov al,numero
loop ciclo_bin
;-------------------------------------------------------
mov cx,0008h ;ciclo para imprimir el número binario
ciclo_print:
pop dx
xchg dh,dl
or dx,3030h
mov ah,02h
int 21h
xor dx,dx
loop ciclo_print
ret
imprimir endp

;--------------------------------------------------------
limpieza proc near
xor ax,ax ;limpiamos los registros para que no exista
xor bx,bx ;un desbordamiento al hacer las operaciones
xor dx,dx
xor cx,cx
ret
limpieza endp
;--------------------------------------------------------
print proc near
mov ah,02h
int 21h
ret
print endp
;--------------------------------------------------------
print_bcd proc near
mov cx,0008h ;ciclo para obtener el numero bcd
mov al,aux
mov bl,dos
ciclo_bcd:
div bl
push ax
mov aux,al
xor ax,ax
mov al,aux
loop ciclo_bcd

mov cx,0008h ;ciclo para imprimir el número binario
ciclo_print2:
pop dx
xchg dh,dl
or dx,3030h
mov ah,02h
int 21h
xor dx,dx
loop ciclo_print2
ret
print_bcd endp
;-------------------
end inicio

PD.-Me deben una pizza, aunque preferiría tener un empleo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

PROBLEMA ENSAMBLADOR 8086

Publicado por Ferofichas (3 intervenciones) el 08/11/2011 17:19:35
favor necesito que alguien me ayude con un programa en emu 8086.
que risiva un numero de 3 digitos por teclado y me diga si es par o impar...??

Graciaas..¡¡
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

PROBLEMA ENSAMBLADOR 8086

Publicado por Angel (1 intervención) el 05/04/2019 01:37:49
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
DATOS SEGMENT PARA PUBLIC 'DATA'
 
RESULT      DB  8  DUP (0)
NUM         DW  16,3,2,7,45,2,87,36,56,12
PARESA       DW  0,0,0,0,0,0,0,0,0,0
IMPARESA     DW  0,0,0,0,0,0,0,0,0,0
 
DATOS       ENDS
 
 
PILA SEGMENT PARA STACK 'STACK'
     DB      64     DUP('STACK')
 
PILA ENDS
 
CODIGO SEGMENT PARA PUBLIC 'CODE'
INICIO PROC FAR
 
       ASSUME CS:CODIGO,DS:DATOS,PILA:STACK
       PUSH   DS
       MOV    AX,0
       PUSH   AX
 
       MOV    AX, DATOS
       MOV    DS,AX
       MOV    ES,AX
       MOV     DI,18
 
 
 
 
 
                                            ;INICIALIZAMOS EL CONTADOR EN 7(NUMERO DE PASADAS DEL CICLO)
 
 
;PROCEDIMIENTO PARA REALIZAR LOS CALCULOS;
REPETIR10:
        MOV     AX,NUM[DI]                                  ;CARGAMOS EN AX EL NUMERO A CONVERTIR
        MOV     BL,2                                        ;CARGAMOS EN BL LA BASE A LA QUE SE CONVERTIRA
        MOV     CX,7
        MOV     SI,7
        MOV     DX, NUM[DI]
        CMP     DX,0
        JZ      IMP_RESULT0
 
        MOV     DX, NUM[DI]                                 ;SI EL NUMERO A CONVERTIR ES 1
        CMP     DX,1
        JZ      IMP_RESULT1
    CALCULO:
        DIV     BL                                          ;SE DIVIDE AX ENTRE BL
                                                            ;SE GUARDA EN AL EL COCIENTE Y EN AH EL RESIDUO
        MOV     RESULT[SI],AH
 
    SEGUIR:                                                 ;GUARDAMOS EL RESIDUO EN EL ARREGLO RESULT
        DEC     SI                                          ;DECREMENTAMOS EL INDICE DEL ARREGLO
        AND     AX,0X00FF                                   ;BORRAMOS AH DE AX (SE BORRA EL ULTIMO RESIDUO)
        CMP     AL,2                                        ;DIVISION ENTRE 2
        JL      IMP_RESULT1
        LOOP    CALCULO                                     ;SE REINCIA EL PROCESO
 
    IMP_RESULT0:
 
        MOV     RESULT[SI],0                                ;COMO EL COCIENTE FUE MENOR QUE LA BASE 2, ENTONCES EL BIT
 
    IMP_RESULT1:
        MOV     RESULT[SI],1
 
        CMP     RESULT[7],0
        JZ      PARES
        CMP     RESULT[7],1
        JZ      IMPARES
    PARES:
        MOV     CX,NUM[DI]
        MOV     PARESA[DI],CX
        JMP     SALIR
 
    IMPARES:
        MOV     CX,NUM[DI]
        MOV     IMPARESA[DI],CX
        JMP     SALIR
 
    SALIR:
        DEC     DI
        DEC     DI
        MOV     CX,7
        MOV     SI,7
    LIMPIAR:
        MOV     RESULT[SI],0
        DEC     SI
        CMP     SI,0
        JL      REPETIR10
        CMP     DI,0
        JL      TERMINAR
        JMP     LIMPIAR
TERMINAR:
        RET
INICIO  ENDP
CODIGO  ENDS
        END     INICIO
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar