[ASSEMBLY]: Conversione stringa in binario

[Gigi83]

salve a tutti, ho un problema con un progetto da sviluppare in assembler....il progetto in breve, è questo:

il programma riceve in ingresso una stringa la cui lunghezza max è 80 caratteri. Letta la stringa la converte in binario e stampa a video il risultato della conversione.

la fase problematica è la fase di conversione della stringa in binario, in quanto riesco a convertire solo l'ultimo carattere. Il sorgente l'ho impostato in questa maniera:


;definizione costanti
PAGINA EQU 00h
HT EQU 09h
LF EQU 0Ah
CR EQU 0Dh
;
BIOS_VIDEO EQU 10H
SET_VIDEO_MODE EQU 00h ;in AH
MODO_TESTO EQU 03H ;in AL
;
SET_CURSOR EQU 02h ;in AH
W_CHR_TTY EQU 0Eh ;in AH
;
DOS EQU 21h
R_KEY_CHR EQU 01h
PRINT_STRING EQU 09h
R_KEY_CHR_NE EQU 07h


DSEG SEGMENT PARA PUBLIC 'DATA'
TITOLO DB 'PROGETTO1$'
ISTRUZIONI DB CR,HT,HT,HT,HT,HT,CR,'Inserire una stringa:$'
BIN_MESS DB CR,LF,HT,HT,'Rappresentazione Binaria: $'
PUNTO DB CR,LF,HT,HT, '.$'

TERMINE DB CR,LF,LF,HT,'Un''altra iterazione? [S/N] $'
ENTER EQU 13
MAX_LUNGH EQU 80
CODICE_TASTO DB MAX_LUNGH DUP(?) ;Sequenza di MAX_LUNGH
LUNGH_SEQU DW ? ;Lunghezza della stringa
PAGIN EQU 00h
INDEX DW MAX_LUNGH DUP(?)
SEQUENZA DB ?
DSEG ENDS

STACKM SEGMENT PARA STACK 'STACK' ; Viene allocata una zona
DB 64 DUP ('12345678') ; memoria per lo Stack: in
STACKM ENDS ; tutto 64*8 bytes


ASSUME CS:CSEG, DSSEG, SS:STACKM
CSEG SEGMENT PARA PUBLIC 'CODE'



;------------------------------------------------------;
; Corpo principale del programma ;
;------------------------------------------------------;

MAIN PROC FAR
PUSH DS ;Istruzioni da lasciare SEMPRE
MOV AX, 00h ;al principio dei programmi!
PUSH AX
CALL INIZIALIZZAZIONE
CICLO_PRINCIPALE: CALL PROMPT
CALL LETTURA_STRINGA
CALL STAMPA_BIN
CALL TEST_FINALE

JNZ CICLO_PRINCIPALE
RET
MAIN ENDP


;-----------------------------------------------------------------------;
; Procedura di inizializzazione ;
; ;
;REGISTRI UTILIZZATI: AX, DX, DS ;
;-----------------------------------------------------------------------;

INIZIALIZZAZIONE PROC NEAR
MOV AX,DSEG ;Inizializzazione segmento dati
MOV DS,AX ; tramite il registro AX.
MOV AH,SET_VIDEO_MODE ;Servizio BIOS 'Set Video Mode':
MOV AL,MODO_TESTO ; modo testo 80 x 25, colori
INT BIOS_VIDEO ;

MOV DX,0315h ;Imposta riga (DH) e colonna (DL)
CALL SPOSTA_CURSORE ;Muove il cursore nella pos scelta

MOV DX,OFFSET TITOLO ;Sceglie la stringa (DSX)
CALL STAMPA_STRINGA ; e la stampa.

MOV DX,0909h ;Imposta riga (DH) e colonna (DL)
CALL SPOSTA_CURSORE ;Muove il cursore nella pos scelta
RET ;Ritorno alla procedura chiamante
INIZIALIZZAZIONE ENDP


;-----------------------------------------------------------------------;
; Procedura per stampare il messaggio iniziale ;
; ;
; REGISTRI UTILIZZATI: DX, AH ;
;-----------------------------------------------------------------------;

PROMPT PROC NEAR
MOV DX,OFFSET ISTRUZIONI ;Sceglie la stringa (DSX)
CALL STAMPA_STRINGA ; e la stampa.
RET ;Ritorno alla procedura chiamante
PROMPT ENDP



;-----------------------------------------------------------------------;
; Procedura per leggere una stringa e memorizzarla in BX ;
; ;
;PARAMETRI: La stringa e' memorizzata in BX ;
;REGISTRI UTILIZZATI: AX,BX,CX,DL ;
;-----------------------------------------------------------------------;

LETTURA_STRINGA PROC NEAR
MOV CX,00h
MOV CX,MAX_LUNGH ;inizializza il contatore caratteri
NUOVA_LETT: MOV AH,08h ;servizio DOS 'Read Keyboard Char
INT 21h ;Without Echo'
CMP AL,ENTER ;se il tasto è ENTER,
JZ FINE_LETTURA ;termina la lettura
PUSH AX ;salva il registro AX
MOV AH,02h ;servizio DOS 'Character Output'
MOV DL,AL ;Carattere da stampare
INT 21h
POP AX ;ripristina il contenuto di AX
MOV [CODICE_TASTO],AL ;Memorizza il tasto
INC BX ;Aggiorna il puntatore
LOOP NUOVA_LETT ;reitera fino a che CX=0

FINE_LETTURA: MOV [LUNGH_SEQU],BX
RET

LETTURA_STRINGA ENDP



STAMPA_BIN PROC NEAR
MOV DX,OFFSET BIN_MESS
CALL STAMPA_STRINGA

MOV BX,0
NEW: MOV DL,[CODICE_TASTO] ;LEGGE IL CODICE DEL TASTO
PUSH BX
MOV BX,[INDEX]
MOV [SEQUENZA+BX],DL
POP BX
INC BX
INC INDEX
MOV DH,00h ;CONTATORE DI BITS
CICLO_BINARIO: XOR AL,AL
SHL DL,01h


ADC AL,AL
CALL STAMPA_NUMERO
INC DH

JNZ CICLO_BINARIO
; CMP BX,[LUNGH_SEQU]


RET
STAMPA_BIN ENDP



;-----------------------------------------------------------------------;
; Procedura per determinare se occorre un'altra iterazione ;
; ;
; EGISTRI UTILIZZATI: AX, DX ;
; CODICI DI RITORNO: ;
; Zero flg = 0 -> un'altra iterazione ;
; Zero flag = 1 -> esci dal programma ;
;-----------------------------------------------------------------------;

TEST_FINALE PROC NEAR
MOV DX,OFFSET TERMINE ;Sceglie la stringa (DSX)
CALL STAMPA_STRINGA ;e la stampa.
CALL LETTURA_SN ;Legge da tastiera senza echo.
CMP AL,'n' ;Modifica il FLAG 'Z'
RET ;Ritorno alla procedura chiamante
TEST_FINALE ENDP


;************************************************* ***********************;
;* Procedure di basso livello di interfaccia *;
;************************************************* ***********************;



SPOSTA_CURSORE PROC NEAR
MOV BH,PAGINA ;Pagina video attiva
MOV AH,02h ;Servizio BIOS 'Set Cursor
INT 10h ;Position'
RET
SPOSTA_CURSORE ENDP

;------------------------------------------------------------------------;
; Procedura per leggere da tastiera uno dei tasti 'S' o 'N' ;
; ritorna solo dopo aver letto almeno uno dei due tasti ;
; ;
; REGISTRI UTILIZZATI: AX ;
; CODICI DI RITORNO: in AL il codice ASCII letto ;
;------------------------------------------------------------------------;

LETTURA_SN PROC NEAR
NUOVA_LETTURA: MOV AH,R_KEY_CHR_NE ;Servizio DOS 'Read Keyboard Char
INT DOS ;Whitout Echo'
OR AL,00100000b ;Converte in minuscolo
CMP AL,'n' ;Se il tasto premuto e' 'N' esce
JZ FINE_LETT ;dalla procedura
CMP AL, 's' ;Se non e' 'S', ne legge
JNZ NUOVA_LETTURA ;un altro
FINE_LETT: RET ;Ritorno alla procedura chiamante
LETTURA_SN ENDP
STAMPA_NUMERO PROC NEAR
ADD AL, '0' ;La base da cui partire e' '0'
MOV AH,W_CHR_TTY ;Servizio BIOS 'write Char in TTY'
INT BIOS_VIDEO
RET ;Ritorno alla procedure chiamante
STAMPA_NUMERO ENDP


STAMPA_STRINGA PROC NEAR
MOV AH,09h ;Servizio DOS 'Print String'; la
INT 21h ;stringa è puntata da DSX.
RET ;ritorno alla procedura chiamante
STAMPA_STRINGA ENDP

CSEG ENDS
END MAIN



Anche guardando il codice vi accorgerete che sono un apprendista dell'assembler e quindi dico a chiunque mi risponda che può fare una grande opera di bene!!!

p.s.: per precisare l'architettura usata è l' 8086.

Grazie in anticipo per le eventuali risposte.

[andbin]

Originariamente inviato da Gigi83
salve a tutti, ho un problema con un progetto da sviluppare in assembler....il progetto in breve, è questo:

il programma riceve in ingresso una stringa la cui lunghezza max è 80 caratteri. Letta la stringa la converte in binario e stampa a video il risultato della conversione.

la fase problematica è la fase di conversione della stringa in binario, in quanto riesco a convertire solo l'ultimo carattere.

Ciao, ho esaminato il sorgente. Ci sono diverse cose che non vanno.

Nella procedura LETTURA_STRINGA qualunque carattere digitato lo metti sempre in [CODICE_TASTO], quindi hai sempre solo 1 carattere nel buffer CODICE_TASTO.
Per risolvere ti consiglio di:
a) Azzerare BX all'inizio della procedura (vedo che fai un MOV CX,00h che è inutile ma credo che volessi azzerare BX)
b) Scrivere in CODICE_TASTO in modo progressivo facendo MOV [CODICE_TASTO+BX],AL

La procedura STAMPA_BIN è un po' strana:
a) Usi 2 variabili INDEX e SEQUENZA che di per sé non servirebbero a nulla
b) Metti un contatore dei bit MOV DH,00h e poi incrementi DH. O controlli quando DH raggiunge 8 oppure fai il contrario: lo metti all'inizio a 8 e poi decrementi fino a 0
c) Non hai gestito il loop per prendere tutta la sequenza di caratteri

[alka]

Io invece ho esaminato il titolo, e ne avrei scelto uno più consono nel rispetto del Regolamento.

Ho modificato il titolo aggiungendo una spiegazione rappresentativa del problema.

Ciao!

[Gigi83]

ciao,purtroppo a causa di forza maggiore non ho potuto utilizzare internet fino a oggi...cmq io ho provato ad apportare alcune modifiche che tu mi hai suggerito in questo modo:

LETTURA_STRINGA PROC NEAR
MOV BX,00h
MOV BX,MAX_LUNGH ;inizializza il contatore caratteri
NUOVA_LETT: MOV AH,08h ;servizio DOS 'Read Keyboard Char
INT 21h ;Without Echo'
CMP AL,ENTER ;se il tasto è ENTER,
JZ FINE_LETTURA ;termina la lettura
PUSH AX ;salva il registro AX
MOV AH,02h ;servizio DOS 'Character Output'
MOV DL,AL ;Carattere da stampare
INT 21h
POP AX ;ripristina il contenuto di AX
MOV [CODICE_TASTO+BX],AL ;Memorizza il tasto
INC BX ;Aggiorna il puntatore
LOOP NUOVA_LETT ;reitera fino a che CX=0

FINE_LETTURA: MOV [LUNGH_SEQU],BX
RET

LETTURA_STRINGA ENDP



STAMPA_BIN PROC NEAR
MOV DX,OFFSET BIN_MESS
CALL STAMPA_STRINGA

MOV BX,0
NEW: MOV DL,[CODICE_TASTO] ;LEGGE IL CODICE DEL TASTO
PUSH BX
MOV BX,[INDEX]
MOV [SEQUENZA+BX],DL
POP BX
INC BX
INC INDEX
MOV DH,00h ;CONTATORE DI BITS
CICLO_BINARIO: XOR AL,AL
SHL DL,01h
ADC AL,AL
CALL STAMPA_NUMERO
INC DH
JNZ CICLO_
RET
STAMPA_BIN ENDP

i problemi ora sono 2:
il primo è che non ho capito bene come modificare la procedura STAMPA_BIN e il secondo è che così come ho modificato il sorgente restituisce 80 volte zero. Naturalmente questi problemi sono causati dalla mia parziale ignoranza in questo linguaggio
Riusciresti a darmi qualche dritta più a basso livello?magari facendomi vedere come modificare quello che tu dici...scusami ma ci sto sbattendo davvero la testa e te ne sarei davvero grato se riuscissi a darmi una mano

[andbin]

Ecco cosa devi modificare:

procedura LETTURA_STRINGA:
- Devi mettere MOV CX,MAX_LUNGH (nota che BX l'hai azzerato appena prima ed è giusto)

procedura STAMPA_BIN, te lo spiego a parole:
- Azzeri BX
- Imposti CX al valore salvato in LUNGH_SEQU
- Fai un loop in cui:
--- Leggi es. in AL il contenuto di [CODICE_TASTO+BX] (come hai fatto in LETTURA_STRINGA ma al contrario)
--- Fai un ulteriore loop interno per scansionare gli 8 bit e stampare 1 o 0
--- Incrementi BX
--- Ripeti il loop (con LOOP, così esaurisci gli N caratteri)

Prova a fare le modifiche, poi se hai problemi, chiedi pure.

[Gigi83]

ciao, prima di tutto vorrei ringraziarti per la disponibilità e la pazienza che stai avendo...
ora vorrei chiederti alcune cose...ho modificato il sorgente in questo modo:

LETTURA_STRINGA PROC NEAR
MOV BX,00h
MOV CX,MAX_LUNGH ;inizializza il contatore caratteri

NUOVA_LETT: MOV AH,08h ;servizio DOS 'Read Keyboard Char
INT 21h ;Without Echo'
CMP AL,ENTER ;se il tasto è ENTER,
JZ FINE_LETTURA ;termina LA lettura
PUSH AX ;salva il registro AX
MOV AH,02h ;servizio DOS 'Character Output'
MOV DL,AL ;Carattere da stampare
INT 21h
POP AX ;ripristina il contenuto di AX
MOV [CODICE_TASTO+BX],AL ;Memorizza il tasto
INC BX ;Aggiorna il puntatore
LOOP NUOVA_LETT ;reitera fino a che CX=0

FINE_LETTURA: MOV [LUNGH_SEQU],BX
RET

LETTURA_STRINGA ENDP



STAMPA_BIN PROC NEAR
MOV DX,OFFSET BIN_MESS
CALL STAMPA_STRINGA

MOV BX,00h
MOV CX,[LUNGH_SEQU]
LEGGI_STRINGA: MOV AH,08h
INT 21h
MOV AL,[CODICE_TASTO+BX] ;LEGGE IL CODICE DEL TASTO
MOV DL,AL
INC BX
LOOP LEGGI_STRINGA
MOV DH,00h ;CONTATORE DI BITS
CICLO_BINARIO: XOR AL,AL
SHL DL,01h
ADC AL,AL
MOV [CONVERSIONE+BX],AL
INC BX
DEC DH
LOOP LEGGI_STRINGA

FINE_CICLO: CALL STAMPA_NUMERO



RET
STAMPA_BIN ENDP


io ho provato a modificare STAMPA_BIN in questo modo però ho dei seri dubbi di aver sbagliato, infatti il compilatore impazzisce e anche io con lui.... VVoVe:
Ah non riesco a capire xkè mi parli di scansionare 8 bit se la mia stringa deve avere al max 80 caratteri

[andbin]

Originariamente inviato da Gigi83
io ho provato a modificare STAMPA_BIN in questo modo però ho dei seri dubbi di aver sbagliato, infatti il compilatore impazzisce e anche io con lui.... VVoVe:
Ah non riesco a capire xkè mi parli di scansionare 8 bit se la mia stringa deve avere al max 80 caratteri

Adesso la procedura LETTURA_STRINGA mi sembra ok! La procedura STAMPA_BIN invece non va ancora bene.

Se ho ben capito, devi visualizzare a video il valore binario di ogni carattere digitato, giusto??

Quindi:
A) Devi fare un loop nel loop. Nel loop esterno prendi progressivamente uno degli N caratteri depositati nel buffer. Nel loop interno scansioni gli 8 bit del carattere e per ognuno stampi '0' oppure '1'.
B) Nella procedura non hai bisogno di fare input con l'INT 21h.

Detto a parole, devi seguire questa procedura:
1) Metti BX=0 e CX=[LUNGH_SEQU]
2) Leggi in AL il carattere puntato da CODICE_TASTO+BX
3) Metti un registro es. DH=8
4) Esamini il bit più alto del carattere e se 1 stampi '1', altrimenti stampi '0'
5) Fai lo shift a sinistra del valore del carattere
6) Decrementi DH
7) Se DH non è zero salti a 4)
8) Incrementi BX
9) Con LOOP salti a 2), cioè fino a quando hai caratteri

Chiaro adesso?

[Gigi83]

grazieeeeeeeeeeeeee!!!!!!!!!sei un mito!!!!ci sono riuscito finalmente!!! ora ti faccio vedere come ho implementato:

LETTURA_STRINGA PROC NEAR
MOV BX,00h
MOV CX,MAX_LUNGH ;inizializza il contatore caratteri

NUOVA_LETT: MOV AH,08h ;servizio DOS 'Read Keyboard Char
INT 21h ;Without Echo'
CMP AL,ENTER ;se il tasto è ENTER,
JZ FINE_LETTURA ;termina LA lettura
PUSH AX ;salva il registro AX
MOV AH,02h ;servizio DOS 'Character Output'
MOV DL,AL ;Carattere da stampare
INT 21h
POP AX ;ripristina il contenuto di AX
MOV [CODICE_TASTO+BX],AL ;Memorizza il tasto
INC BX ;Aggiorna il puntatore
LOOP NUOVA_LETT ;reitera fino a che CX=0

FINE_LETTURA: MOV [LUNGH_SEQU],BX
RET

LETTURA_STRINGA ENDP



STAMPA_BIN PROC NEAR
MOV DX,OFFSET BIN_MESS
CALL STAMPA_STRINGA

MOV BX,00h
MOV CX,[LUNGH_SEQU]

LEGGI_STRINGA: MOV AL,CODICE_TASTO+BX ;LEGGE IL CODICE DEL TASTO
MOV DH,08h
MOV DL,AL
CICLO_BINARIO: XOR AL,AL
SHL DL,01h
ADC AL,AL
CALL STAMPA_NUMERO
DEC DH
JNZ CICLO_BINARIO


FINE_CICLO: INC BX
LOOP LEGGI_STRINGA



RET
STAMPA_BIN ENDP



ora, se non ti rompo troppo, volevo chiederti un 'altra cosa. Praticamente il mio programmino deve effettuare una codifica run lenght della stringa binaria ottenuta. Per codifica run lenght intendo questo:
CODIFICA RUN_LENGHT

PARTENDO DALLA SEQUENZA DI BIT OTTENUTA TRAMITE LA CONVERSIONE IN BINARIO DELLA STRINGA INSERITA,DEVO FARE ESEGUIRE LA SEGUENTE CODIFICA:

-IL PRIMO BIT DELLA SEQUENZA ENTRA DIRETTAMENTE NELLA CODIFICA.

-SEGUE LA LUNGHEZZA ESPRESSA IN DECIMALE DEL NUMERO DI VOLTE CHE IL COMPLEMENTO COMPARE NELLA STRINGA E COSì VIA.

-SEGUE LA LUNGHEZZA ESPRESSA IN DECIMALE DEL NUMERO DI VOLTE CHE IL COMPLEMENTO COMPARE NELLA STRINGA E COSì VIA.

ESEMPIO

SEQUENZA DI BIT:1111111111111111.0000000000000000.000100000001 0000.0000000000000000
CODIFICA: 1 16 19 1 7 1 20

ora il problema è che secondo me, con il codice così come è impostato, non posso riuscire a fare la codifica run lenght perchè la stringa binaria non la memorizzo in nessuna locazione vero?
riusciresti a darmi qualche dritta così come hai fatto alla grande con la procedura STAMPA_BIN? la procedura per la codifica run lenght la chiamerò STAMPA_RUN

[oregon]

Scusa Gigi83 ... sei la stessa persona che ha in nick Shin83 ?

[Gigi83]

no perchè?