[ASSEMBLY] Convertire in binario, ottale ed esadecimale

[Andrea93]

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]

scusate scusate scusate per il titolo cmq era tipo "problema conversioni"

[Andrea93]

non mi riesce per favore helpatemi

[linoma]

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]

non potevo farlo in c... sennò l'avrei fatto...
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]

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]

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...

[linoma]

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]

il problema è che uso sempre quella e non so perchè da questo errore... cambio solo il valore che dovrà dividere 2 --> 8

[linoma]

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.