PDA

Visualizza la versione completa : [ASSEMBLY] Convertire in binario, ottale ed esadecimale


Andrea93
12-05-2010, 17:16
Allora innanzitutto ciao a tutti...
Mi chiamo Andrea sono di pistoia faccio l' ITIS specializzazione informatica e sono in terza

Mi stato assegnato il seguente esercizio:

dato un numero o la somma di due numeri decimali convertire in binario ottale ed esadecimale...
fin qui tutto bene, ho fatto l'input e l'eventuale somma e torna, la conversione binaria ed esadecimale tornano, ma quella ottale mi crea problemi dal numero 128 in su ( mi da come risultato sempre 1 ) ( il numero max da convertire 198 )... il metodo che h ousato quello delle divisioni progressive :


conv_ott:
mov cont, 1
mov pot, 8
confronto1:
sub ax, ax
sub bx, bx
mov bl, cont
mov al, ns31
div pot
mov ns31, al
mov v[bx], ah
inc cont
cmp al, 0
jne confronto1
dec cont
lea dx, acapo
mov ah, 9
int 21h
lea dx, otta
mov ah, 9
int 21h

stampa1:
sub bx, bx
mov bl, cont
mov dl, v[bx]
add dl, 30h
mov ah, 2
int 21h
dec cont
cmp cont, 0
jne stampa1

sicuramente avr usato istruzioni e metodi non eleganti ma sono all' inizissimo e anche per eventuali soluzioni non usate macro o altra roba complessa

grazie

Andrea93
12-05-2010, 17:18
scusate scusate scusate per il titolo cmq era tipo "problema conversioni"

Andrea93
13-05-2010, 19:00
non mi riesce :dh: :dh: :dh: per favore helpatemi

linoma
13-05-2010, 20:59
Io sto cercando da ieri, ma nn mi parte il programmino, cm fai? Ho provato anche a fare un thunk a 16 bits, mi stai facendo impazzire. NN potevi farlo in c?

Andrea93
13-05-2010, 21:27
:bh: non potevo farlo in c... senn l'avrei fatto... :bh:
cmq ti posto tutto il codice del programma (l'emu il tasm)




.MODEL SMALL
.STACK 200h

.DATA ;definizione variabili e stringhe da stampare a video

msg0 DB "Inserire numero: $"
msg1 DB "Inserire primo numero: $"
msg2 DB "Inserire secondo numero: $"
menu DB "Scegliere somma e conversioni (1) o conversioni (2) : $"
ris DB "La somma : $"
otta DB "Il numero in ottale : $"
hexa DB "Il numero in esadecimale : $"
bina DB "Il numero in binario : $"
acapo DB 13,10,"$"
n1 DB ?
n11 DB ?
n2 DB ?
n22 DB ?
ns1 DB ?
ns2 DB ?
ns3 DB ?
pot DB 2
cont DB 1
v DB 1,2,3,4,5,6,7,8
ns31 DB ?
ns32 DB ?

.CODE

mov ax, @data
mov ds, ax


scelta:


lea dx, menu
mov ah, 9
int 21h ;stampa menu
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h
cmp al, 2
je conversione
jmp somma


conversione:


lea dx, acapo
mov ah, 9
int 21h

lea dx, msg0
mov ah, 9
int 21h ;stampa messaggio 0
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h ;toglie 30 esadecimale per trasformare da ascii a decimale
mov ns2, al
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h ;toglie 30 esadecimale per trasformare da ascii a decimale
mov ns3, al
mov ns1, 0


conv:


lea dx, acapo
mov ah, 9
int 21h ;butta a capo

mov al, 10
mul ns2
add ns3, al

mov al, 100
mul ns1
add ns3, al
mov al, ns3
mov ns31, al
mov ns32, al


conv_bin:


confronto:
sub ax, ax
sub bx, bx
mov bl, cont
mov al, ns3
div pot
mov ns3, al
mov v[bx], ah
inc cont
cmp al, 0
jne confronto

dec cont
lea dx, acapo
mov ah, 9
int 21h
lea dx, bina
mov ah, 9
int 21h

stampa:
sub bx, bx
mov bl, cont
mov dl, v[bx]
add dl, 30h
mov ah, 2
int 21h
dec cont
cmp cont, 0
jne stampa


conv_ott:


mov cont, 1
mov pot, 8

confronto1:
sub ax, ax
sub bx, bx
mov bl, cont
mov al, ns31
div pot
mov ns31, al
mov v[bx], ah
inc cont
cmp al, 0
jne confronto1

dec cont
lea dx, acapo
mov ah, 9
int 21h
lea dx, otta
mov ah, 9
int 21h

stampa1:
sub bx, bx
mov bl, cont
mov dl, v[bx]
add dl, 30h
mov ah, 2
int 21h
dec cont
cmp cont, 0
jne stampa1


conv_hex:


mov cont, 1
mov pot, 16

confronto2:
sub ax, ax
sub bx, bx
mov bl, cont
mov al, ns32
div pot
mov ns32, al
mov v[bx], ah
inc cont
cmp al, 0
jne confronto2

dec cont
lea dx, acapo
mov ah, 9
int 21h
lea dx, hexa
mov ah, 9
int 21h

stampa2:
sub bx, bx
mov bl, cont
mov dl, v[bx]
add dl, 30h
cmp dl, 39h
jg add39
print:
mov ah, 2
int 21h
dec cont
cmp cont, 0
jne stampa2
jmp fine
add39:
add dl, 39
jmp print


jmp fine


somma:

lea dx, acapo
mov ah, 9
int 21h

lea dx, msg1
mov ah, 9
int 21h ;stampa messaggio 1
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h ;toglie 30 esadecimale per trasformare da ascii a decimale
mov n1, al
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h ;toglie 30 esadecimale per trasformare da ascii a decimale
mov n11, al

lea dx, acapo
mov ah, 9
int 21h ;butta a capo

lea dx, msg2
mov ah, 9
int 21h ;stampa messaggio 2
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h ;toglie 30 esadecimale per trasformare da ascii a decimale
mov n2, al
mov ah, 1
int 21h ;acquisisce il valore
sub al, 30h ;toglie 30 esadecimale per trasformare da ascii a decimale
mov n22, al

lea dx, acapo
mov ah, 9
int 21h ;butta a capo


sub ax, ax
mov al, n11
add al, n22
cmp al, 10
jb unacifra1 ;se la somma < di 10 la fa direttamente
;altrimenti fa il riporto e fa la somma togliendo 10

mov ns2, 1 ;ci sar sicuramente riporto e mette a 1 le decine
sub ax,ax
mov ah, n11
add ah, n22
sub ah, 10
mov ns3, ah ;somma i numeri togliendo 10 cos da le unit e assegna
jmp short continuo1

unacifra1:
sub ax, ax
mov al, n11
add al, n22
mov ns3, al ;somma e assegna le unit
mov ns2, 0

continuo1:
sub ax, ax
mov al, n1
add al, n2
add al, ns2
cmp al, 10
jb unacifra2 ;se la somma < di 10 la fa direttamente
;altrimenti fa il riporto e fa la somma togliendo 10

mov ns1, 1 ;ci sar sicuramente riporto e mette a 1 le centinaia
sub ax,ax
mov ah, n1
add ah, n2
add ah, ns2
sub ah, 10
mov ns2, ah ;somma i numeri togliendo 10 cos da le decine e assegna
jmp short continuo2

unacifra2:
sub ax, ax
mov al, n1
add al, n2
add al, ns2
mov ns2, al ;somma e assegna le unit
mov ns1, 0

continuo2:

lea dx, ris
mov ah, 9
int 21h

mov dl, ns1
add dl, 30h
mov ah, 2
int 21h ;stampa centinaia

mov dl, ns2
add dl, 30h
mov ah, 2
int 21h ;stampa decine

mov dl, ns3
add dl, 30h
mov ah, 2
int 21h ;stampa unit

lea dx, acapo
mov ah, 9
int 21h

jmp conv

fine:
mov ah, 4ch
int 21h

END
END

e ti ripeto funziona tutto alla perfezione... solo ottale e solo oltre il 127 non funge...

linoma
14-05-2010, 05:43
Senza troppo leggere il prg, div usa 2 registri AX e DX, mi sembra che DX nn sia inizializzato
E cmq stampa un'esempio del errore che ti restituisce.

Andrea93
14-05-2010, 11:49
il risultato sbagliato 1 fisso per le conversioni da 128 in su ( solo ottale )
il div usa due registri per i dati di grandezza word, per quelli di tipo byte sfruttano al per il resto e ah per il quoziente o viceversa non mi ricordo... :dh: :dh: :dh: :dh: :dh: :dh: :dh:

linoma
14-05-2010, 11:58
Ripeto senza neanche leggere tutto quel codice, visto che dici che solo ottale nn ti funge. Evidentemente ce ne un'altra che ti funge. Usa sempre quella.

Andrea93
14-05-2010, 14:28
il problema che uso sempre quella e non so perch da questo errore... cambio solo il valore che dovr dividere 2 --> 8 :dh: :dh: :dh: :dh: :dh:

linoma
14-05-2010, 15:20
Evidentemente sbagliata anche quella. Credo sinceramente, basandomi su quello che dici e ripeto senza leggere il codice, che sia sbagliato l'algoritmo che usi.
Normalmente in questi casi si usa carta e penna, anche visto la difficolta del linguaggio. Non dico, di fare un diagramma a blocchi, ma almeno usare un metalinguaggio si. Grosso modo dovresti fare divisioni fino a che il tuo numero nn sia inferiore alla base e considerare i resti. Ecco se questo quello a cui stai pensando siamo sulla buona strada.
Poi devi passarlo in asm. Nn capisco il motivo di ricorrere agli int etc etc, ma se li tralasci, usando anche del codice misto al C, sarebbe meglio.

Loading