[Assembler] Convertitore Binario-Decimale

[Lupino.86]

Save a tutti,
potete aiutarmi a scrivere un convertitore Binario-Decimale usando il linguaggio Assembler?
Conosco il linguaggio, ma mi pare che sia una bella gatta da pelare.....voi che dite?



Vi ringrazio anticipatamente,
Lupino.86

[cionci]

Cioè prendi un input binario da tastiera (solo 0 e 1 da tastiera) ?

[Lupino.86]

Originariamente inviato da cionci

Cioè prendi un input binario da tastiera (solo 0 e 1 da tastiera) ?

No..... devo acquisire da tastiera un numero decimale, convertirlo in binario.

Successivamente devo anche scrivere un programma per moltiplicare due numeri decimali utilizzando però i numeri binari:
1) acquisisto il moltiplicando decimale
2) acquisisto il moltiplicatore decimale
3) converto moltiplicando e moltiplicatore in binario
4) eseguo la moltiplicazione utlizzando le cifre binarie e non decimali
5) il risultato binario lo converto in decimale


Per ora mi basta sapere la sola conversione

[Goldrake_xyz]

beh, acquisire da tastiera con l'assembler mi sembra un proggetto
piuttosto impegnativo, a meno che non hai delle routine già pronte.
se riesci a salvare la cifra decimale in memoria in BCD ad esempio,
poi è facile da convertire in binario puro.
la conversione devi farla in binario complemento 2 ?
una volta convertiti usa la famosa istruzione IMUL xyz
se invece sono numeri reali, con la virgola, la questione si complica
xchè c'è bisogno di convertirli in esponente e mantissa normalizzati
e poi darli in pasto al coprocessore numerico ...

ciao

P.S. x la conversione di numeri interi da dec. a binario usando l'asm
è abbastanza semplice. come anche il vice-versa

[Goldrake_xyz]

Acc dovrei averlo scritto un programmino del genere, (tanti anni fà )
se lo ritrovo, lo allego

[Lupino.86]

Originariamente inviato da Goldrake_xyz

beh, acquisire da tastiera con l'assembler mi sembra un proggetto
piuttosto impegnativo, a meno che non hai delle routine già pronte.

Cosa intendi per routine???

se riesci a salvare la cifra decimale in memoria in BCD ad esempio,
poi è facile da convertire in binario puro.

So salvare in memoria la cifra decimale tramite la divisione per 10..... ma nn so convertire da decimale a binario!

la conversione devi farla in binario complemento 2 ?

prchè esiste qualche altra conversione binaria?

una volta convertiti usa la famosa istruzione IMUL xyz
se invece sono numeri reali, con la virgola, la questione si complica
xchè c'è bisogno di convertirli in esponente e mantissa normalizzati
e poi darli in pasto al coprocessore numerico ...

Nonononono, sono numeri senza virgola.
L'istruzione IMUL mi da sempre errore.... cosa sbaglio?
per esempio: IMUL bl,bx ; moltiplico il registro Bl con il registro BX, il risultavo va a finire in BL.... tutto OK?

P.S. x la conversione di numeri interi da dec. a binario usando l'asm
è abbastanza semplice. come anche il vice-versa

Se è semplice MI PUOI DIRE COME SI Fà ???

[Lupino.86]

Originariamente inviato da Goldrake_xyz

Acc dovrei averlo scritto un programmino del genere, (tanti anni fà )
se lo ritrovo, lo allego

Spero con ansia che hai tuttora quel programmino

[71104]

Originariamente inviato da Lupino.86

Cosa intendi per routine???

funzioni, procedure, sottoprogrammi, sub; al limite vanno bene anche le macro
cmq acquisire da tastiera diventa semplicissimo se il file che devi generare è un binario puro (estensione .com): in tal caso basta usare il bios emulato da Windows.

[cionci]

Originariamente inviato da Lupino.86

per esempio: IMUL bl,bx ; moltiplico il registro Bl con il registro BX, il risultavo va a finire in BL.... tutto OK?

Non puoi usare bh e bx come operatori... bl fa parte di bx...

[cj++]

scrivilo in C poi usa il codice ottimizzato generato dal compilatore

[repne scasb]

Non hai specificato il sistema operativo, ne la modalita' del processore; ho scelto io DOS/WIN_VM modalita' reale:

	ENTER_KEY1		EQU	1C0Dh
	ENTER_KEY2		EQU	0E00Dh
	BACKSPACE_KEY		EQU	0E08h

	data	segment byte 'DATA'

dos_message_1:
	DB	'Moltiplicazioni in ASM',0Dh,0Ah,'$'
dos_message_2:
	DB	0Dh,0Ah,'Inserire 1° operando: $'
dos_message_3:
	DB	0Dh,0Ah,'Inserire 2° operando: $'
dos_message_4:
	DB	0Dh,0Ah,0Dh,0Ah,'Risultato: $'

_1st_val_str:
	DB	0Ah DUP (?)
_2nd_val_str:
	DB	0Ah DUP (?)
_1st_val_bin:
	DD	?
_2nd_val_bin:
	DD	?

	data	ends

	.386P
	.ALPHA

	code	segment para use16 'CODE'
	assume	cs:code

	Init	proc	near

	push	DATA
	pop	ds
	mov	dx,OFFSET dos_message_1
	call	Write_Message
	mov	dx,OFFSET dos_message_2
	call	Write_Message
	mov	si,OFFSET _1st_val_str
	call	Get_Input
	mov	di,OFFSET _1st_val_bin
	call	Str_Dec_To_Bin
	mov	dx,OFFSET dos_message_3
	call	Write_Message
	mov	si,OFFSET _2nd_val_str
	call	Get_Input
	mov	di,OFFSET _2nd_val_bin
	call	Str_Dec_To_Bin
	mov	dx,OFFSET dos_message_4
	call	Write_Message
	mov	eax,ds: dword ptr [_2nd_val_bin]
	mul	ds: dword ptr [_1st_val_bin]
	call	Write_Dec_Num64
	mov	ax,4C00h
	int	21h

	init	endp

;#############################################################################

	Get_Input	proc	near

	pusha
	xor	bx,bx
loop_get_key:
	call	Get_Key
	cmp	bx,9h
	je	test_alt_key
	cmp	ah,2h
	jb	test_num_alt
	cmp	ah,0Bh
	ja	test_num_alt
test_num_low:
	cmp	al,'0'
	jb	test_num_alt
	cmp	al,'9'
	ja	test_num_alt
	call	Write_Char
	mov	ds: byte ptr [bx+si],al
	inc	bx
	jmp	loop_get_key
test_num_alt:
	cmp	ah,47h
	jb	test_alt_key
	cmp	ah,52h
	jbe	test_num_low
test_alt_key:
	cmp	ax,BACKSPACE_KEY
	jne	test_exit
	or	bx,bx
	je	loop_get_key
	call	Get_Cursor_Position
	dec	dl
	call	Set_Cursor_Position
	dec	bx	
	mov	al,' '
	call	Write_Char
	call	Set_Cursor_Position
	jmp	loop_get_key
test_exit:
	cmp	ax,ENTER_KEY1
	je	exit_get_input
	cmp	ax,ENTER_KEY2
	jne	loop_get_key
exit_get_input:
	mov	ds: byte ptr [bx+si],0h
	popa
	ret

	Get_Input	endp

;#############################################################################

	Get_Key	proc	near

	pusha
	mov	ah,10h
	int	16h
	mov	bp,sp
	mov	ss: word ptr [bp+0Eh],ax
	popa
	ret

	Get_Key	endp

;#############################################################################

	Str_Dec_To_Bin	proc	near

	pushad
	mov	ds: dword ptr [di],0h
	call	Str_Len
	or	ax,ax
	je	exit_str_dec_to_bin
	dec	ax
	xchg	ax,bx
	xor	eax,eax
	mov	edx,1h
loop_char_str:
	movzx	ecx,ds: byte ptr [bx+si]
	sub	cl,'0'
	imul	ecx,edx
	add	eax,ecx	
	imul	edx,10d
	sub	bx,1h
	jnc	loop_char_str
	mov	ds: dword ptr [di],eax
exit_str_dec_to_bin:
	popad
	ret

	Str_Dec_To_Bin	endp

;#############################################################################

	Write_Dec_Num64	proc	near

	pushad
	push	eax
	push	edx
	mov	edi,0Ah
	xor	bh,bh
next_dec_long_left:
	push	eax
	mov	eax,edx
	xor	edx,edx
	div	edi
	mov	ebp,eax
	pop	eax
	div	edi
	mov	edx,ebp
	inc	bh
	or	edx,edx
	jne	next_dec_long_left
	or	eax,eax
	jne	next_dec_long_left
	call	Get_Cursor_Position
	add	dl,bh
	dec	dl
	call	Set_Cursor_Position
	pop	edx
	pop	eax
	mov	ebx,0Ah
next_dec_long:
	push	eax
	mov	eax,edx
	xor	edx,edx
	div	ebx
	mov	ebp,eax
	pop	eax
	div	ebx
	add	dl,'0'
	xchg	ax,dx
	call	Write_Char
	xchg	ax,dx
	call	Get_Cursor_Position
	sub	dl,2h
	call	Set_Cursor_Position
	mov	edx,ebp
	or	edx,edx
	jne	next_dec_long
	or	eax,eax
	jne	next_dec_long
	popad
	ret

	Write_Dec_Num64	endp

;#############################################################################

	Write_Message	proc	near

	pusha
	mov	ah,9h
	int	21h
	popa
	ret

	Write_Message	endp

;#############################################################################

	Write_Char	proc	near

	pusha
	mov	ah,0Eh
	int	10h
	popa
	ret

	Write_Char	endp

;#############################################################################

	Set_Cursor_Position	proc	near

	pusha
	mov	ah,2h
	xor	bh,bh
	int	10h
	popa
	ret

	Set_Cursor_Position	endp

;#############################################################################

	Get_Cursor_Position	proc	near

	pusha
	mov	ah,3h
	xor	bh,bh
	int	10h
	mov	bp,sp
	mov	ss: word ptr [bp+0Ah],dx
	popa
	ret

	Get_Cursor_Position	endp

	Str_Len	proc	near

	push	es
	push	ds
	pop	es
	push	cx
	push	di
	mov	di,si
	mov	cx,0FFFFh
	xor	al,al
	repne	scasb
	not	cx
	dec	cx
	xchg	ax,cx
	pop	di
	pop	cx
	pop	es
	ret

	Str_Len	endp

	code	ends
	end	init

In allegato troverai l'eseguibile. A meno di bug "sembra funzionare" (ho avuto a disposizione poco tempo), non ci sono commente in quanto il sorgente e' autoespicativo, spero ti sia utile a scopo didattico.

[Goldrake_xyz]

I numeri binari possono anche essere in complemento 2,
questa rappresentazione è usata per i numeri interi positivi e negativi.
Ad esempio in binario normale si ha con 8 bit
Min = 00000000 = 0 ; MAX = 11111111 = 255
mentre in complemento 2 si hanno i valori (sempre x 8 bit)
Min = 10000000 = -128 ; MAX = 011111111 = 127

E questo si riflette anche nel linguaggio C, gli unsigned char è un byte
che può essere convertito in un intero da 0 a 255, mentre
i signed char possono essere convertiti in un numero da -128 a 127

IMUL è un' istruzione per la moltiplicazione di interi con segno,
cioè di numeri binari complemento2,

MUL è un' istruzione pre la moltiplicazione di interi senza segno,
cioè di numeri binari positivi

Esempio : voglio moltiplicare n1 x n2 (ovviamente n1 e n2 sono cifre)

MOV AX, n1 ; carico il registro AX
MOV BX, n2 ; carico il registro BX

IMUL BX ; esegue la moltiplicazione

IL risultato viene messo nei registri DX,AX

[Goldrake_xyz]

Sto cercando di trovare il programma che mi hai chiesto,
frà le migliaia di file dei miei programmi ...

Ah eccone uno (in allegato)
Scritto mooolto tempo fà x MS-DOS e compilato con il TURBO ASSEMBLER 2.0,
a quel tempo non esistevano i caratteri proporzionali, e quindi
il programma può risultare disallineato ...

Ciao

[Goldrake_xyz]

Ooops, nel programma allegato si può anche vedere l'uso delle istruzioni
MUL e DIV con registri a 32 Bit (del 386 : EAX, EBX, ecc. ecc.)
Cmq. per fare la conversione si possono usare anche altri metodi,
che sono forse anche migliori ...
Su google si trova tutto !

Ciao

[Lupino.86]

Originariamente inviato da cionci

Non puoi usare bh e bx come operatori... bl fa parte di bx...

Era un esempio stupido....... più scemo che stupido

[Lupino.86]

Originariamente inviato da cj++

scrivilo in C poi usa il codice ottimizzato generato dal compilatore

Come come come?

[Lupino.86]

Originariamente inviato da repne scasb

Non hai specificato il sistema operativo, ne la modalita' del processore; ho scelto io DOS/WIN_VM modalita' reale:


In allegato troverai l'eseguibile. A meno di bug "sembra funzionare" (ho avuto a disposizione poco tempo), non ci sono commente in quanto il sorgente e' autoespicativo, spero ti sia utile a scopo didattico.

Inanzitutto ti ringrazio per il codice sorgente e l'eseguibile.

Scusa la totale ignoranza in materia, ma credo di nn sbagliare se ti dico che lavoriamo con DOS (al massimo scriviamo con il NotePad e salviamo in .ASM) e usiamo la programmazione Intel 80x86


Cmq ti giuro che nn ho MAi visto certe istruzioni....... potreti spiegarmele oppure devo trovarmi una guida?
Questo programma converte solo da decimale a binario oppure fa anche la moltiplicazione binaria e stampa il risultato convertito in decimale?

[cionci]

Originariamente inviato da Lupino.86

fa anche la moltiplicazione binaria

Rifletti su quanto hai detto...non esiste una moltiplicazione binaria, intera o esadeciamale... Una moltiplicazione è una moltiplicazione e basta... La base in cui esprimi operatori e risultato non contano...

[Lupino.86]

Originariamente inviato da Goldrake_xyz

IMUL è un' istruzione per la moltiplicazione di interi con segno,
cioè di numeri binari complemento2,

MUL è un' istruzione pre la moltiplicazione di interi senza segno,
cioè di numeri binari positivi

io devo usare l'istruzione MUL perchè nn mi importa del segno..... però moltiplicare i numeri negativi sarebbe una finezza da pochi!


Posso dire che nn ho capito bene come si comporta la funzione MUL?

[Lupino.86]

Originariamente inviato da cionci

Rifletti su quanto hai detto...non esiste una moltiplicazione binaria, intera o esadeciamale... Una moltiplicazione è una moltiplicazione e basta... La base in cui esprimi operatori e risultato non contano...

Sono d'accordo..... nn mi sono spiegato bene: la moltiplicazione deve essere eseguita a livello binario cioè con numeri binari

00000101 = 5
00000010 = 2
00000110= ----> stampo 10

cioè il programma deve convertire in binario, moltiplicare con i numeri binari e stampare a video il numero decimale