Caricare documenti e articoli online  
INFtube.com è un sito progettato per cercare i documenti in vari tipi di file e il caricamento di articoli online.
Meneame
 
Non ricordi la password?  ››  Iscriviti gratis
 

ROVA PRATICA #1

tecnica


Inviare l'articolo a Facebook Inviala documento ad un amico Appunto e analisi gratis - tweeter Scheda libro l'a yahoo - corso di


ALTRI DOCUMENTI

GAGARIN
IL CONDENSATORE PIANO - GENERALITA' SUI CONDENSATORI
IL PORTAFOGLIO S.B.F - INCASSI ELETTRONICI CON PROCEDURA RI.BA
ESERCIZI - Calcolare i seguenti integrali definiti
MAGNETISMO NEL MODELLO DI HUBBARD
OSCILLATORE ARMONICO - AUTOSTATI DELL'ENERGIA
La modellizzazione stocastica
ESPERIENZA ED ARPA DI NIKURADSE, NELL'AMBITO DEL MOTO TURBOLENTO IN TUBI COMMERCIALI.
PROPAGAZIONE UNIDIMENSIONALE
MECCANICA STATISTICA QUANTISTICA

;PROVA PRATICA #1

;Scrivere un programma che legge da tastiera e fa l'eco su video dei

;caratteri letti, con le seguenti particolaritā:

;1) all'inizio il programma stampa il prorpio nome, cognome e numero di

;matricola di seguito e va a capo;

;2) il carattere <CR> (ritorno carrello, codisce ascii 13) viene stampato

;come <CR> seguito da <LF> (line feed, codice ascii 10);

;3) i caratteri con codice ascii diversi da 13, 32..126 sono ignorati;

;4) quando si riceve la stringa "QUIT" (4 lettere maiuscole) seguita da CR

;il programma termina;

;5) quando viene battuto uno spazio o un ritorno carrello, il programma

;stampa il carattere battuto seguito dall'ultima parola letta, fra parentesi

;quadre e da uno spazio

;



;Esempio:l'utente batte

;                prova di scrittura. Batto<CR>QUIT e poi da QUIT<CR>

;        il programma scrive su video

;                Giunta Pisano numero di matricola 000001

;                prova [prova] di [di] scrittura. [scrittura.] Batto 838f53i

;                [Batto] QUIT [QUIT] e [e] poi [poi] da [da] QUIT

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

        BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

        MESS BYTE 'Paolo Corsini # di matricola 000002',0AH, 0DH

mydata  ENDS

mycode  SEGMENT 'CODE'

        ASSUME ES:SELECTOR mydata

eco     PROC NEAR

        MOV AL,'['

        CALL OUTPUT

        SUB DI,SI

        MOV CX,DI

        MOV BX,SI

        MOV DI,SI

        CALL OUTMESS

        MOV AL,']'

        CALL OUTPUT

        MOV AL,' '

        CALL OUTPUT

        RET

eco     ENDP

ver     PROC NEAR

        PUSH DI

        MOV DI,SI

        CMP BY ES:[DI],'Q'

        JNE fine

        INC DI

        CMP BY ES:[DI],'U'

        JNE fine

        INC DI

        CMP BY ES:[DI],'I'

        JNE fine

        INC DI

        CMP BY ES:[DI],'T'

        JNE fine

        MOV BX,0FABH

        JMP fine

fine:   POP DI

        RET

ver     ENDP

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV ES,AX

        MOV DX,ES

        MOV BX,OFFSET MESS

        CALL NEWLINE

        CALL OUTLINE

        MOV SI,24H

        MOV DI,SI

        MOV AX,0

        MOV BX,0

start:  CALL INPUT

        CMP AL,32H

        JB lab1

        CMP AL,7FH

        JE start

        MOV ES:[DI],AL

        INC DI

        CALL OUTPUT

        JMP start

lab1:   CMP AL,20H

        JE spazio

        CMP AL,0DH 

        JNE start

        CALL ver

        CMP BX,0FABH

        JE uscita

        CALL OUTPUT          

        MOV AL,0AH

        CALL OUTPUT

        CALL eco

        JMP start

spazio: CALL OUTPUT

        CALL eco

        JMP start

uscita: .EXIT

main    ENDP

mycode  ENDS

        END main

;PROVA PRATICA #2

;Scrivere un programma che, partendo da uno stato iniziale in cui n=20

;esegue ciclicamente le seguenti azioni:

;1) legge un carattere c

;        - se c='q' termina;

;        - se c='l' e n>0 decrementa n;

;        - se c='r' e n<40 incrementa n;

;        - negli altri casi lascia n immutato.

;2) se n=0  stampa "|BONG...... 37 .......|"

;   se n=40 stampa "|........ 37 .....BONG|"

;   altrimenti     "|.. n ...0... 40-n ...|"

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

        BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

        N       BYTE 14H

        MESS1   BYTE '|BONG...... 37 .......|', 0DH,0AH

        MESS2   BYTE '|........ 37 .....BONG|', 0DH,0AH

        HEAD    BYTE '|.. '

        BODY    BYTE ' ...0... '

        FOOT    BYTE ' ...|'

mydata  ENDS

mycode  SEGMENT 'CODE'

        ASSUME ES:SELECTOR mydata

main    PROC FAR

        MOV AX, SELECTOR mydata

        MOV ES, AX

start:  CALL INPUT

        CMP AL,71H

        JZ quit

        CMP AL,72H

        JZ incr

        CMP AL,6CH

        JZ decr

        JMP print

decr:   CMP N,0

        JBE print

        DEC N

        JMP print

incr:   CMP N,28H

        JAE print

        INC N

        JMP print

print:  MOV DX,ES

        MOV AX,0

        CALL NEWLINE

        CMP N,0

        JZ msg1

        CMP N,28H

        JZ msg2

        MOV BX,OFFSET HEAD

        MOV CX,4

        CALL OUTMESS

        MOV AL,N

        MOV CX,2

        CALL B16DAN_out

        MOV BX,OFFSET BODY

        MOV CX,9

        CALL OUTMESS

        MOV AL,28H

        SUB AL,N

        MOV CX,2

        CALL B16DAN_out

        MOV BX,OFFSET FOOT

        MOV CX,5

        CALL OUTMESS

        JMP start

msg1:   MOV BX,OFFSET MESS1

        CALL OUTLINE

        JMP start

msg2:   MOV BX,OFFSET MESS2

        CALL OUTLINE

        JMP start

quit:   .EXIT

main    ENDP

mycode  ENDS

        END main

;PROVA PRATICA #3

;Scrivere un programma che simula il sommatore modulare per numeri

;naturali a 6 cifre in base dieci. Il programma deve eseguire ciclicamente

;le seguenti operazioni

;1) leggere da tastiera X e Y su 6 cifre in base 10, e C0 su una cifra

;in base 2, facendo gli opportuni controlli;

;2) stampare X, Y, il risultato Z=X+Y e i riporti intermedi Ci

;3) termina quando il risulato vale 616460

INCLUDE  compatib

INCLUDE  utility

mystack     SEGMENT   STACK

        BYTE 400H DUP (?)

mystack     ENDS

mydata      SEGMENT

        MESS1   BYTE 'Inserisci X: 6 cifre in base 10',0AH,0DH

        MESS2   BYTE 'Inserisci Y: 6 cifre in base 10',0AH,0DH

        MESS3   BYTE 'Inserisci il riporto C0: 0 o 1?',0AH,0DH

        MESS4   BYTE 'X+Y= '

        MESS5   BYTE 'I riporti intermedi C6 .. C1 sono',0AH,0DH

        C0      BYTE ?

        NUMX    BYTE 6 DUP (?)

        NUMY    BYTE 6 DUP (?)

        SOMMA   BYTE 6 DUP (0)

        RIPORTI BYTE 6 DUP (0)

mydata      ENDS

mycode      SEGMENT 'CODE'

        ASSUME ES:SELECTOR mydata

somme   PROC NEAR

        MOV SI,6

ripeti: ADD AL,NUMX[SI-1]

        ADD AL,NUMY[SI-1]

        CMP AL,0AH

        JAE go

        ADD AL,30H

        MOV SOMMA[SI-1],AL

        JMP cifra

go:     SUB AL,10D

        ADD AL,30H

        MOV SOMMA[SI-1],AL

        MOV RIPORTI[SI-1],1

        JMP step

cifra:  MOV RIPORTI[SI-1],0

step:   MOV AL,RIPORTI[SI-1]

        DEC SI

        JNZ ripeti

        RET

somme   ENDP

stampa  PROC NEAR

        MOV BX,OFFSET MESS4

        MOV CX,5

        CALL OUTMESS

        MOV SI,0

still:  MOV AL,SOMMA[SI]

        CALL OUTPUT

        INC SI

        CMP SI,6

        JNZ still

        CALL NEWLINE

        MOV BX,OFFSET MESS5

        CALL OUTLINE

        MOV SI,0

ancora: MOV AL,RIPORTI[SI]

        ADD AL,30H

        CALL OUTPUT

        INC SI

        CMP SI,6

        JNZ ancora

        RET

stampa  ENDP

ver     PROC NEAR

        MOV AL,RIPORTI[0]

        CMP AL,0

        JNZ fine

        MOV AL,SOMMA[0]

        CMP AL,'6'

        JNZ fine

        MOV AL,SOMMA[1]

        CMP AL,'1'

        JNZ fine

        MOV AL,SOMMA[2]

        CMP AL,'6'

        JNZ fine

        MOV AL,SOMMA[3]

        CMP AL,'4'

        JNZ fine

        MOV AL,SOMMA[4]

        CMP AL,'6'

        JNZ fine

        MOV AL,SOMMA[5]

        CMP AL,'0'

        JNZ fine

        MOV AL,'Y'

fine:   RET

ver     ENDP

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV ES,AX

start:  CALL NEWLINE

        MOV DX,ES

        MOV BX,OFFSET MESS1

        CALL OUTLINE

        MOV SI,0

cicl0:  CALL inDA1_eco

        SUB AL,30H

        MOV NUMX[SI],AL

        INC SI

        CMP SI,6

        JNZ cicl0

        CALL NEWLINE

        MOV BX,OFFSET MESS2

        CALL OUTLINE

        MOV SI,0

cicl1:  CALL inDA1_eco

        SUB AL,30H

        MOV NUMY[SI],AL

        INC SI

        CMP SI,6

        JNZ cicl1

        CALL NEWLINE

        MOV BX,OFFSET MESS3

        CALL OUTLINE

ciclo:  CALL INPUT

        CMP AL,'0'

        JB ciclo

        CMP AL,'1'

        JA ciclo

        CALL OUTPUT

        CALL NEWLINE

        SUB AL,30H

        CALL somme

        CALL stampa

        CALL ver

        CMP AL,'Y'

        JNZ start

      .EXIT

main  ENDP

mycode      ENDS

      END   main

;PROVA PRATICA #4

;Simulare un processore dotato di un registro ad 8 bit (R0), program

;counter ad 8 bit e 256 bytes di memoria e in grado di eseguire le

;seguenti istruzioni

;opcode          mnemonico       descrizione

;00              CLR             azzera il registro R0

;01 n            ADD n           somma al registro un intero n su 8

;                                bit in complemento a 2

;02              PRINT           stampa su video il contenuto di R0

;                                in decimale seguito da CR e LF

;03 addr         JNZ addr        salta all'indirizzo addr se R0 Č diverso da 0

;04              HALT            ferma il processore simulato

;

;Programmare il processore simulato per far eseguire il seguente programma

;(in linguaggio macchia, da caricare nella memoria simulata a partire

;dall'indirizzo 0):

;

;00h 01h 20h 02h 01h 0FFh 03h 03h 04h

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

        BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

        R0      BYTE ?

        MESS1   BYTE 'INVALID OPCODE',0AH,0DH

        MESS2   BYTE 'R0='

        MARK    LABEL BYTE

mydata  ENDS

mycode  SEGMENT 'CODE'

        ASSUME ES:SELECTOR mydata

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV ES,AX

        MOV SI,OFFSET MARK

        MOV BY ES:[SI],00H               ;Carico il programma in memoria

        MOV BY ES:[SI+1],01H

        MOV BY ES:[SI+2],20H

        MOV BY ES:[SI+3],02H

        MOV BY ES:[SI+4],01H

        MOV BY ES:[SI+5],0FFH

        MOV BY ES:[SI+6],03H

        MOV BY ES:[SI+7],03H

        MOV BY ES:[SI+8],04H

        MOV BX,0

start:  MOV AL,ES:[SI+BX]

        INC BX

        CMP AL,00H

        JZ clr

        CMP AL,01H

        JZ somma

        CMP AL,02H

        JZ stampa

        CMP AL,03H

        JZ salto

        CMP AL,04H       

        JZ stop

        MOV DX,ES

        PUSH BX

        MOV BX,OFFSET MESS1

        CALL OUTLINE

        POP BX

        JMP stop

clr:    MOV R0,00H

        JMP start

somma:  MOV CL,ES:[SI+BX]

        INC BX

        ADD R0,CL

        JMP start

stampa: MOV DX,ES

        PUSH BX

        MOV BX,OFFSET MESS2

        MOV CX,3

        CALL OUTMESS

        POP BX

        MOV AH,0

        MOV AL,R0

        AND AL,10000000b

        JNZ nega

        MOV AL,R0

        MOV CX,3

        CALL B16DAN_out

        CALL NEWLINE

        JMP start

nega:   MOV AL,2DH

        CALL OUTPUT

        MOV AL,R0

        NOT AL

        INC AL

        MOV CX,3

        CALL B16DAN_out

        CALL NEWLINE

        JMP start

salto:  CMP R0,0

        JZ start

        MOV AL,ES:[SI+BX]

        MOV BL,AL

        JMP start

stop:   .EXIT

main    ENDP

mycode  ENDS

        END main

;PROVA PRATICA #5

;Scrivere un programma che si comporta come segue:

;1) legge da tastiera un numero natura N su due cifre in base 5,

;   facendo gli opportuni controlli sulle cifre accettate;

;2) stampa la riga

;

;        (XX)5 = (YY)10  [+++++++++++++++++]

;

;   dove XX Č il numero N espresso in base 5, YY su base 10

;   e il numero di caratteri '+' Č pari ad N

;3) se N=0 termina, altrimenti torna al passo 1

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

        BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

mydata  ENDS

mycode  SEGMENT 'CODE'

        ASSUME DS:SELECTOR mydata

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV DS,AX

        MOV AX,0

start0: CALL input

        CMP AL,30H

        JB start0

        CMP AL,34H

        JA start0

        CALL output

        MOV DH,AL

start1: CALL input

        CMP AL,30H

        JB start1

        CMP AL,34H

        JA start1

        CALL output

        CALL newline

        MOV DL,AL

        MOV AL,'('

        CALL output

        MOV AL,DH

        CALL output

        MOV AL,DL

        CALL output

        MOV AL,')'

        CALL output

        MOV AL,'5'

        CALL output

        MOV AL,'='

        CALL output        ;(xx)5=

        MOV AL,DL

        CALL HA1B4

        MOV DL,AL

        MOV AL,DH

        CALL HA1B4

        MOV CL,05H

        MUL CL

        ADD DL,AL

        MOV AL,28H

        CALL output

        MOV AL,DL

        MOV CX,2

        CALL B16DAN_out

        MOV AL,29H

        CALL output

        MOV AL,31H

        CALL output

        MOV AL,30H      ;(yy)10

        CALL output

        MOV AL,20H

        CALL output

        MOV AL,5BH

        CALL output

        CMP DL,0

        JZ fine

        MOV AL,2BH

ciclo:  CALL output

        DEC DL

        JNZ ciclo

        MOV AL,5DH

        CALL output

        CALL newline

        JMP start0

fine:   MOV AL,5DH

        CALL output

       .EXIT

main    ENDP

mycode  ENDS

        END main

;PROVA PRATICA #6

;Scrivere un programma che esegue ciclicamente le seguenti azioni:

;1) legge da tastiera la rappresentazione, in complemento, su 3 cifre

;   in base 8, del numero intero a

;2) disegna sullo schermo un rettangolo pieno di

;        larghezza = 5 + ABS(a)/10

;        altezza   = 4 + [ABS(a) modulo 10]

;   usando il carattere "+" se a>=0, "-" se a<0

INCLUDE compatib

INCLUDE utility

mystack     SEGMENT STACK

      BYTE  400H DUP (?)

mystack     ENDS

mydata      SEGMENT

        MESS    BYTE 'Inserisci un numero su tre cifre in base 8',0AH,0DH

        BUFF    BYTE 3 DUP (?)

        ABS     WORD 0

        LARG    WORD 5

        ALTZ    WORD 4

        SEGNO   BYTE ?

mydata      ENDS

mycode      SEGMENT 'CODE'

      ASSUME   DS:SELECTOR mydata

indata  PROC NEAR

        MOV SI,0

start:  CALL INPUT

        CMP AL,'0'

        JB start

        CMP AL,'7'

        JA start

        CALL OUTPUT

        MOV BUFF[SI],AL

        INC SI

        CMP SI,3

        JNE start

        MOV AL,BUFF[2]  ;CONVERSIONE DA 3 ASCII A 3 CIFRE IN BASE 8

        SUB AL,30h

        MOV CX,1d

        MUL CL

        ADD ABS,AX



        MOV AL,BUFF[1]

        SUB AL,30h

        MOV CX,8d

        MUL CL

        ADD ABS,AX

        MOV AL,BUFF[0]

        SUB AL,30h

        MOV CX,64d

        MUL CL

        ADD ABS,AX

        CMP BUFF[0],'4'

        JB pos

        MOV SEGNO,'-'   ;RICAVO IL VALORE ASSOLUTO SE NUM<0

        MOV AX,ABS

        ADD AX,0FE00H

        NEG AX

        MOV ABS,AX

        JMP fine

pos:    MOV SEGNO,'+'

fine:   RET

indata  ENDP

stampa  PROC NEAR

        CALL NEWLINE

        MOV AL,SEGNO

        MOV BX,LARG

        MOV CX,ALTZ

ripeti: CALL OUTPUT

        DEC BX

        JNZ ripeti

        CALL NEWLINE

        DEC CX

        MOV BX,LARG

        JNZ ripeti

        RET

stampa  ENDP

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV DS,AX

        MOV DX,DS

        MOV BX,OFFSET MESS

        CALL OUTLINE

        CALL indata

        MOV DX,0

        MOV AX,ABS

        MOV BX,0AH

        DIV BX

        ADD LARG,AX

        ADD ALTZ,DX

        CALL stampa

      .EXIT

main  ENDP

mycode      ENDS

      END   main

;PROVA PRATICA #7

;Scrivere un programma che si comporta come segue:

;

;1) legge da tastiera un numero naturale su tre cifre in base tre,

;   assegnandone il valore alla variabile LATO;

;2) legge da tastiera un carattere minuscolo che rappresenta una vocale;

;3) disegna un rettangolo pieno di larghezza LATO e altezza LATO/2

;   utilizzando la vocale letta in precedenza;

;4) legge un carattere da tastiera accetando solo: '+', '-' e 'q';

;5) se il carattere letto Č 'q' termina;

;6) se il carattere letto Č '+' o '-' incrementa o decrementa la variabile

;   LATO (mantenedone per. 5<=LATO<=40) e torna al passo 3

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

        BYTE 1024 DUP (?)

mystack ENDS

mydata  SEGMENT

        MESS1 BYTE 'Inserisci un # di 3 cifre in base 3',0DH,0AH

        MESS2 BYTE 'Dammi una vocale...',0DH,0AH

        VETT BYTE 3 DUP (?)

        LATO BYTE ?

        VOC BYTE ?

mydata  ENDS

mycode  SEGMENT 'CODE'

        ASSUME DS:SELECTOR mydata

conv    PROC NEAR

        CMP AL,'0'

        JZ zero

        CMP AL,'1'

        JZ uno

        CMP AL,'2'

        JZ due

zero:   MOV AL,0000

        JMP fine

uno:    MOV AL,0001

        JMP fine

due:    MOV AL,0002

fine:   RET

conv    ENDP

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV DS,AX

        MOV DX,DS

start0: CALL NEWLINE

        MOV BX,OFFSET MESS1

        CALL OUTLINE

        CALL NEWLINE

        MOV DI,3

start:  CALL INPUT

        CMP AL,30H

        JB start

        CMP AL,32H

        JA start

        CALL OUTPUT

        MOV VETT[DI-1],AL

        DEC DI

        JNZ start

        MOV AX,0

        MOV AL,VETT[0]

        CALL conv

        MOV LATO,AL

        MOV AL,VETT[1]

        CALL conv

        MOV CX,3

        MUL CL

        ADD LATO,AL

        MOV AL,VETT[2]

        CALL conv

        MOV CX,9

        MUL CL

        ADD LATO,AL

        CMP LATO,0

        JZ start0

        CMP LATO,1

        JZ start0

        CALL NEWLINE

        MOV BX,OFFSET MESS2

        CALL OUTLINE

        CALL NEWLINE

vocale: CALL INPUT

        CMP AL,'a'

        JZ ok

        CMP AL,'e'

        JZ ok

        CMP AL,'i'

        JZ ok

        CMP AL,'o'

        JZ ok

        CMP AL,'u'

        JNZ vocale

ok:     MOV VOC,AL

stampa: CALL NEWLINE

        MOV CL,LATO

        MOV AL,LATO

        MOV AH,0

        MOV BL,2

        DIV BL

        MOV BL,AL

        MOV AL,VOC

goon:   CALL OUTPUT

        DEC CL

        JNZ goon

        CALL NEWLINE

        DEC BL

        MOV CL,LATO

        JNZ goon

ingr:   CALL INPUT

        CMP AL,'q'

        JZ fine

        CMP AL,'+'

        JZ incr

        CMP AL,'-'

        JZ decr

        JMP ingr

decr:   CMP LATO,5

        JZ stmp1

        DEC LATO

stmp1:  JMP stampa

incr:   CMP LATO,40

        JZ stmp2

        INC LATO

stmp2:  JMP stampa

fine:   .EXIT

main    ENDP

mycode  ENDS

        END main

;PROVA PRATICA #8

;Scrivere un programma che:

;1. legge da tastiera, con eco, una stringa di max 40 caratteri,

;   terminata da un ritorno carrello

;2. su una nuova linea stampa la stringa sostituendo ai caratteri

;   di posizione PARI il carattere '_' (underscore)

;3. su una nuova linea stampa la stringa sostituendo ai caratteri

;   di posizione DISPARI il carattere ' ' (spazio)

;4. se la stringa battuta inizia con 'FINE' termina, altrimenti

;   torna al punto 1.

INCLUDE compatib

INCLUDE utility

mystack        SEGMENT STACK

               BYTE 512 DUP (?)

mystack        ENDS              

mydata         SEGMENT

vett           BYTE 42 DUP (?)  

mydata         ENDS

mycode         SEGMENT 'CODE'

               ASSUME DS:SELECTOR mydata

main           PROC FAR

               MOV AX,SELECTOR mydata

               MOV DS,AX

chiama:        MOV DX,DS       ;Prende la stringa di caratteri

               MOV BX,OFFSET vett

               MOV CX,42

               CALL inline_eco

               MOV DI,0

ciclo:         CMP vett[DI],0DH

               JE avanti

               INC DI

               JMP ciclo

avanti:        DEC DI

               MOV SI, 0

               MOV CX, DI

pari:          MOV AL, vett[SI]

               CALL output

               INC SI

               DEC CX

               JZ sotto

               MOV AL,' '

               CALL output

               INC SI

               DEC CX

               JNZ pari

sotto:         CALL newline

               MOV SI,1

dispari:       MOV AL, ' '

               CALL output 

               MOV AL,vett[SI]

               CALL output

               ADD SI,2

               CMP SI,DI

               JB dispari

               CALL newline

               ;Controlla se la stringa e' 'FINE'

               CMP vett[0],'F'

               JNE chiama

               CMP vett[1],'I'

               JNE chiama

               CMP vett[2],'N'

               JNE chiama

               CMP vett[3],'E'

               JNE chiama

               .EXIT

main           ENDP

mycode         ENDS

               END main

;PROVA PRATICA #9

;Scrivere un programma che:

;

;1) legge da tastiera un numero su quattro cifre in base due, che costituisce

;   la rappresentazione in complemento a 2 su quattro cifre di un intero

;   relativo "a";

;2) stampa il valore di a in base 10, in modulo e segno;

;3) se a>0 stampa una striscia lunga a di asterischi "*";

;4) se a<0 stampa una striscia lunga -a di cancelletti "#";

;5) se a=0 termina, altrimenti torna al passo 1

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

      BYTE    400H DUP (?)

mystack ENDS

mydata  SEGMENT

      MESS0   BYTE    'Inserisci un numero su 4 cifre in base 2 in c.r.',0AH,0DH

      NUM     BYTE 4 DUP (?)

      A       BYTE ?

      SEGNO   BYTE ?

mydata  ENDS

mycode  SEGMENT 'CODE'

      ASSUME   DS:SELECTOR mydata

indata  PROC NEAR

      MOV SI,OFFSET NUM

      MOV BX,0

start:  CALL INPUT

      CMP AL,'0'

      JB start

      CMP AL,'1'

      JA start

      CALL OUTPUT

      MOV NUM[SI+BX],AL

      INC BX

      CMP BX,4

      JNE start

      RET

indata  ENDP

conver  PROC NEAR

      MOV CL,8

      MOV SI,OFFSET NUM

      MOV BX,0

      MOV AL,NUM[SI+BX]

      CMP AL,'1'

      JE nega

posi:   SHR CL,1

      INC BX

      CMP BX,4

      JE fine

      MOV AL,NUM[SI+BX]

      CMP AL,'1'

      JNE posi

      ADD A,CL

      JMP posi

nega:   SHR CL,1

      INC BX

      CMP BX,4

      JE fine

      MOV AL,NUM[SI+BX]

      CMP AL,'0'

      JNE nega

      ADD A,CL

      JMP nega

fine:   MOV AL,NUM[SI]

      CMP AL,'1'

      JNE bye1

      INC A

      MOV SEGNO,'-'

      JMP bye2

bye1:   MOV SEGNO,'+'

bye2:   RET

conver  ENDP

stampa  PROC NEAR

      CALL NEWLINE

      MOV AL,SEGNO

      CALL OUTPUT

      MOV AX,0

      MOV AL,A

      CMP AL,0

      JE via

      MOV CX,1

      CALL B16DAN_out

      MOV CL,AL

      CALL NEWLINE

      CMP SEGNO,'+'

      JE ast

canc:   MOV AL,'#'

      JMP ciclo

ast:    MOV AL,'*'

ciclo:  CALL OUTPUT

      DEC CX

      JNZ ciclo

via:    RET

stampa  ENDP

main    PROC FAR

      MOV AX,SELECTOR mydata

      MOV DS,AX

beg:    MOV A,0

      MOV DX,DS

      MOV BX,OFFSET MESS0

      CALL NEWLINE

      CALL OUTLINE

      CALL INDATA

      CALL NEWLINE

      CALL CONVER

      CALL STAMPA

      CMP AL,0

      JNE beg

      .EXIT

main    ENDP

mycode  ENDS

      END     main

;PROVA PRATICA #10

;Scrivere un programma che simuli l'unitā descritta come segue:

;

;x:              4 bit varible

;A,B,D:          4 bit registers

;ror(4 bit):     4 bit produced

;

;RST:    A:=1; B:=2; D:=3

;L0:     A:=x; B:=ror(A); D:=ror(x);

;        goto

;L1:     B:=D; D:=ror(A);

;        goto

;

;All'avvio del programma l'unitā si porta nello stato di reset.

;Da tastiera si batte una cifra esadecimale "x" seguita da CR che

;rappresenta il clock.

;Il circuito risponde stampando il contenuto di STAR, A, B, D

;dopo il clock

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

        BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

        RegA BYTE ?

        RegB BYTE ?

        RegD BYTE ?

        BUFF BYTE ?

        MJR BYTE 0

        MJROLD BYTE 0

        MESS0 BYTE 'Inserisci x',0DH,0AH

        MESS1 BYTE 'STAR:= '

        MESS2 BYTE 'A= '

        MESS3 BYTE 'B= '

        MESS4 BYTE 'D= '

mydata  ENDS

mycode  SEGMENT 'CODE'

        ASSUME ES:SELECTOR mydata

indata  PROC NEAR

        MOV DX,ES

        MOV BX,OFFSET MESS0

        CALL OUTLINE

        CALL NEWLINE

        MOV BUFF,0

        MOV CX,4

        MOV DX,8

begin:  CALL INPUT

        CMP AL,'0'

        JZ ok

        CMP AL,'1'

        JNZ begin

ok:     CALL OUTPUT

        CALL HA1B4

        MUL DL

        SHR DL,1

        ADD BUFF,AL

        DEC CX

        JNZ begin

        CALL NEWLINE

        RET

indata  ENDP

ctrl    PROC NEAR

        PUSH AX

        MOV AL,MJR

        MOV MJROLD,AL

        MOV BL,RegB

        MOV DL,RegD

        CMP BL,DL

        JNZ mjr1

        MOV MJR,0

        JMP fine

mjr1:   MOV MJR,1

fine:   POP AX

        RET

ctrl    ENDP

bin_out PROC NEAR

        PUSH CX

        MOV CX,4

        SHL AL,1

        SHL AL,1

        SHL AL,1

        SHL AL,1

        SHL AL,1

        JNC zero

        JMP uno

still:  SHL AL,1

        JNC zero

uno:    PUSH AX

        MOV AL,'1'

        CALL OUTPUT

        POP AX

        DEC CX

        JZ bye

        JMP still

zero:   PUSH AX

        MOV AL,'0'

        CALL OUTPUT

        POP AX

        DEC CX

        JZ bye

        JMP still

bye:    POP CX

        RET

bin_out ENDP

stmp    PROC NEAR

        PUSH AX

        PUSH BX

        PUSH CX

        PUSH DX

more:   CALL INPUT

        CMP AL,0DH

        JNZ more

        MOV DX,ES

        MOV BX,OFFSET MESS1

        MOV CX,7

        CALL OUTMESS

        MOV AL,'L'

        CALL OUTPUT

        CMP MJROLD,0

        JZ stmpL0

stmpL1: MOV AL,'1'

        CALL OUTPUT

        JMP regs

stmpL0: MOV AL,'0'

        CALL OUTPUT

regs:   CALL NEWLINE

        MOV BX,OFFSET MESS2

        MOV CX,3

        CALL OUTMESS

        MOV AH,0

        MOV AL,RegA

        CALL bin_out

        CALL NEWLINE

        MOV BX,OFFSET MESS3

        MOV CX,3

        CALL OUTMESS

        MOV AH,0

        MOV AL,RegB

        CALL bin_out

        CALL NEWLINE

        MOV BX,OFFSET MESS4

        MOV CX,3

        CALL OUTMESS

        MOV AH,0

        MOV AL,RegD

        CALL bin_out

        CALL NEWLINE

        POP DX

        POP CX

        POP BX

        POP AX

        RET

stmp    ENDP

main    PROC FAR

        MOV AX,SELECTOR mydata

        MOV ES,AX

rst:    MOV RegA,1

        MOV RegB,2

        MOV RegD,3

L0:     CALL ctrl

        CALL indata

        MOV AH,0

        MOV AL,RegA

        SHR AX,1

        JNC next

        ADD AL,1000B

next:   MOV RegB,AL     ;B:=ROR(A)

        MOV AL,BUFF

        MOV RegA,AL     ;A:=X

        MOV AH,0

        SHR AX,1

        JNC next1

        ADD AL,1000B

next1:  MOV RegD,AL     ;D:=ROR(X)

        CALL stmp       ;fase di stampa

        CMP MJR,0

        JZ L0

L1:     CALL ctrl

        MOV DL,RegD

        MOV RegB,DL     ;B:=D

        MOV AL,RegA

        MOV AH,0

        SHR AX,1

        JNC next2

        ADD AL,1000B

next2:  MOV RegD,AL     ;D:=ROR(A)

        CALL stmp       ;fase di stampa

        CMP MJR,0

        JZ L0

        JMP L1

        .EXIT

main    ENDP

mycode  ENDS

        END main



Articolo informazione


Hits: 876
Apprezzato: scheda appunto

Commentare questo articolo:

Non sei registrato
Devi essere registrato per commentare

ISCRIVITI

E 'stato utile?



Copiare il codice

nella pagina web del tuo sito.


Copyright InfTub.com 2017