diff --git a/ES11-02/FREDDO.ASM b/ES11-02/FREDDO.ASM new file mode 100644 index 0000000000000000000000000000000000000000..f2330c5fff063742dab6bc72314d0c79f713b8d2 --- /dev/null +++ b/ES11-02/FREDDO.ASM @@ -0,0 +1,63 @@ +; File: FREDDO.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 14/02/2022 +; +; Descrizione: Data una variabile T contenente la temperatura dell'ambiente, +; memorizzare in un'altra variabile I l'indice di comfort corrispondente +; +; INDICE DI COMFORT TEMPERATURA AMBIENTE (in °C) +; ------------------ ---------------------------- +; 0 molto freddo t < -5 molto freddo +; 1 freddo -5 <= t < 15 freddo +; 2 gradevole 15 <= t < 25 gradevole +; 3 caldo 25 <= t < 33 caldo +; 4 molto caldo t >= 33 molto caldo +; + +TITLE Esercizio 11/02/2022 FREDDO +.MODEL SMALL + +.STACK +.DATA + SOGLIA1 EQU -5 + SOGLIA2 EQU 15 + SOGLIA3 EQU 25 + SOGLIA4 EQU 33 + + T DB 21 ; Temperatura dell'ambiente (in °C) + I DB ? +.CODE + .STARTUP + MOV AL, T ; Carico la temperatura in un registro (confronti piu' rapidi) + CMP AL, SOGLIA1 + JL MOLTOFREDDO + CMP AL, SOGLIA2 + JL FREDDO + CMP AL, SOGLIA3 + JL GRADEVOLE + CMP AL, SOGLIA4 + JL CALDO + ; L'ultima alternativa e': Molto caldo + JMP MOLTOCALDO +MOLTOFREDDO: + MOV I, 0 + JMP FINE +FREDDO: + MOV I, 1 + JMP FINE +GRADEVOLE: + MOV I, 2 + JMP FINE +CALDO: + MOV I, 3 + JMP FINE +MOLTOCALDO: + MOV I, 4 + +FINE: + MOV AH, 0 + MOV AL, I ; Copio l'indice in un registro per facilitare il debugging + .EXIT +END diff --git a/ES11-02/MASSIMO1.ASM b/ES11-02/MASSIMO1.ASM new file mode 100644 index 0000000000000000000000000000000000000000..ad1c83862d9c72a268be11c272ac4023dfffa777 --- /dev/null +++ b/ES11-02/MASSIMO1.ASM @@ -0,0 +1,30 @@ +; File: MASSIMO1.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 14/02/2022 +; +; Descrizione: Dati due numeri a 16 bit memorizzati a partire +; dall'indirizzo 0100h, copiare in AX il numero maggiore. + +TITLE Esercizio 11/02/2022 MASSIMO1 +.MODEL SMALL + +.STACK +.DATA +.CODE + .STARTUP + MOV BX, 0100h + ; Valori considerati con segno + MOV WORD PTR [BX], -512 + MOV WORD PTR [BX+2], 256 + + MOV AX, [BX] ; Copia i valori da confrontare in AX e DX + MOV DX, [BX+2] + CMP AX,DX + JGE FINE ; Se AX contiene il numero maggiore, si puo' terminare + XCHG AX, DX ; Scambio dei due registri + +FINE: + .EXIT +END diff --git a/ES11-02/MASSIMO2.ASM b/ES11-02/MASSIMO2.ASM new file mode 100644 index 0000000000000000000000000000000000000000..e6413e7cd663d99c78a067f918a58316b2e8691c --- /dev/null +++ b/ES11-02/MASSIMO2.ASM @@ -0,0 +1,40 @@ +; File: MASSIMO2.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 14/02/2022 +; +; Descrizione: Dati tre numeri a 16 bit memorizzati a partire +; dall'indirizzo 0100h, copiare in AX il numero maggiore. + +TITLE Esercizio 11/02/2022 MASSIMO2 +.MODEL SMALL + +.STACK +.DATA +.CODE + .STARTUP + MOV BX, 0100h + ; Valori considerati con segno + MOV WORD PTR [BX], -512 + MOV WORD PTR [BX+2], 256 + MOV WORD PTR [BX+4], 0 + + ; Confronto tra i primi due numeri + MOV AX, [BX] ; Copia i valori da confrontare in AX e DX + MOV DX, [BX+2] + CMP AX,DX + JGE CONFRONTONUM3 ; Se AX contiene il numero maggiore, si passa + ; direttamente al confronto con il terzo numero + XCHG AX, DX ; Scambio dei due registri + +CONFRONTONUM3: + MOV DX, [BX+4] ; Carico il terzo numero in DX + CMP AX,DX + + JGE FINE ; Se AX contiene il numero maggiore, si puo' terminare + XCHG AX, DX ; Scambio dei due registri + +FINE: + .EXIT +END diff --git a/ES11-02/NEGATIVI.ASM b/ES11-02/NEGATIVI.ASM new file mode 100644 index 0000000000000000000000000000000000000000..6b081c08f35da0b6b7914502c24a8de830dae503 --- /dev/null +++ b/ES11-02/NEGATIVI.ASM @@ -0,0 +1,44 @@ +; File: NEGATIVI.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 14/02/2022 +; +; Descrizione: Caricare in memoria quatttro numeri relativi +; a 16 bit a partire dall'indirizzo 0100h. +; Successivamente, contare il numero di valori +; negativi e memorizzare il conteggio nel registro CL. +; + +TITLE Esercizio 11/02/2022 NEGATIVI +.MODEL SMALL + +.STACK +.DATA +.CODE + .STARTUP + MOV BX, 0100h + MOV WORD PTR [BX], -30000 + MOV WORD PTR [BX+2], 32000 + MOV WORD PTR [BX+4], 0 + MOV WORD PTR [BX+6], -1 + + MOV CL, 0 + CMP WORD PTR [BX], 0 + JGE SECONDO + INC CL +SECONDO: + CMP WORD PTR [BX+2], 0 + JGE TERZO + INC CL +TERZO: + CMP WORD PTR [BX+4], 0 + JGE QUARTO + INC CL +QUARTO: + CMP WORD PTR [BX+6], 0 + JGE FINE + INC CL +FINE: + .EXIT +END diff --git a/ES11-02/NEGCICLO.ASM b/ES11-02/NEGCICLO.ASM new file mode 100644 index 0000000000000000000000000000000000000000..37a3eddeba05d0f7c0e6ddfc2e1ba810110811a2 --- /dev/null +++ b/ES11-02/NEGCICLO.ASM @@ -0,0 +1,41 @@ +; File: NEGCICLO.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 14/02/2022 +; +; Descrizione: Caricare in memoria quatttro numeri relativi +; a 16 bit a partire dall'indirizzo 0100h. +; Successivamente, contare il numero di valori +; negativi e memorizzare il conteggio nel registro CL. +; VERSIONE ITERATIVA + +TITLE Esercizio 11/02/2022 NEGCICLO +.MODEL SMALL + +.STACK +.DATA +.CODE + .STARTUP + MOV BX, 0100h + MOV WORD PTR [BX], -30000 + MOV WORD PTR [BX+2], 32000 + MOV WORD PTR [BX+4], 0 + MOV WORD PTR [BX+6], -1 + + MOV CL, 0 + MOV SI, 0 +CICLO: + CMP SI, 6 + JA FINE ; Finisce se SI > 6 + CMP WORD PTR [BX + SI], 0 + JGE CONTINUA ; passa alla word successiva se il dato e' >= 0 + INC CL ; Il dato è negativo, incrementiamo CL +CONTINUA: + INC SI + INC SI + JMP CICLO + +FINE: + .EXIT +END diff --git a/ES11-02/PARI.ASM b/ES11-02/PARI.ASM new file mode 100644 index 0000000000000000000000000000000000000000..42e2190cbf6056c902c5ab0df5750de036365161 --- /dev/null +++ b/ES11-02/PARI.ASM @@ -0,0 +1,31 @@ +; File: PARI.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 14/02/2022 +; +; Descrizione: Dato un numero naturale N (8 bit), memorizzare nel registro CL +; il numero 1 se N e' pari, il numero 0 se N e' dispari. + +TITLE Esercizio 11/02/2022 PARI +.MODEL SMALL + +.STACK +.DATA + N DB 124 +.CODE + .STARTUP + MOV AL, N + TEST AL, 1 ; In questo test, se il bit lsb di AL è zero + ; (cioe' se AL e' pari), il risultato del test + ; e' zero e il flag ZF e' attivato (impostato a 1) + JZ PARI + ; Il numero non e' pari + MOV CL, 0 + JMP FINE +PARI: + MOV CL, 1 + +FINE: + .EXIT +END diff --git a/IO/LEGGI_I.ASM b/IO/LEGGI_I.ASM new file mode 100644 index 0000000000000000000000000000000000000000..e2ee0a44768af0999c9b1537f77fa7bfdf4140aa --- /dev/null +++ b/IO/LEGGI_I.ASM @@ -0,0 +1,71 @@ +; File: LEGGI_U.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 17/02/2022 +; +; Descrizione: Legge da tastiera un numero con segno a 16 bit +; utilizzando il servizio DOS 21h. +; Memorizza il risultato nel registro DX. +; + +TITLE LEGGI_I +.MODEL SMALL + +.STACK +.DATA + DIECI DW 10 + SEGNO DB '+' +.CODE + .STARTUP + + MOV DX, 0 ; Il registro DX conterra' alla fine il numero letto + MOV AH, 01h +INIZIO_LETTURA: + INT 21h ; Lettura di un carattere da tastiera (AH = 01) e memorizzazione del suo codice ASCII in AL + CMP AL, ' ' ; Si scartano gli eventuali spazi o caratteri di controllo presenti prima del numero + JBE INIZIO_LETTURA + + CMP AL, '+' ; Verifica l'eventuale presenza del segno + JE ELABORA_SEGNO + CMP AL, '-' + JE ELABORA_SEGNO + JMP ELABORA_CIFRA ; Nessun segno presente, non e' quindi necessario elaborarlo + +ELABORA_SEGNO: + MOV SEGNO, AL + INT 21h ; Legge un altro carattere + +ELABORA_CIFRA: + CMP AL, '0' + JB VALUTA_SEGNO ; L'elaborazione termina in presenza di un carattere non numerico + CMP AL, '9' + JA VALUTA_SEGNO + + MOV AH, 0 + SUB AL, '0' ; Il codice ASCII della cifra letta e' convertita un un numero + PUSH AX ; Il registro AX serve per eseguire una moltiplicazione, si conserva quindi + ; il suo valore nello stack + + ; Operazione DX = DX * 10 + AX + MOV AX, DX ; Copio in AX il valore iniziale di DX + MUL DIECI ; Moltiplico AX per 10 .... + MOV DX, AX ; e colloco il risultato in DX + + POP AX ; Si recupera il valore precedentemente collocato nello stack... + ADD DX, AX ; ... e lo si aggiunge a DX + + MOV AH, 01h ; Legge un altro carattere da tastiera + INT 21h + JMP ELABORA_CIFRA + +VALUTA_SEGNO: + ; se il segno e' '-', occorre cambiare il segno del numero contenuto in DX + CMP SEGNO, '-' + JNE FINE_LETTURA + NEG DX ; Complementa a due il registro DX + +FINE_LETTURA: + + .EXIT +END diff --git a/IO/LEGGI_U.ASM b/IO/LEGGI_U.ASM new file mode 100644 index 0000000000000000000000000000000000000000..7e04ef0f970bbb104c30282a6021c7368e1810f5 --- /dev/null +++ b/IO/LEGGI_U.ASM @@ -0,0 +1,53 @@ +; File: LEGGI_U.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 17/02/2022 +; +; Descrizione: Legge da tastiera un numero senza segno a 16 bit +; utilizzando il servizio DOS 21h. +; Memorizza il risultato nel registro DX. +; + +TITLE LEGGI_U +.MODEL SMALL + +.STACK +.DATA + DIECI DW 10 +.CODE + .STARTUP + + MOV DX, 0 ; Il registro DX conterra' alla fine il numero letto + MOV AH, 01h +INIZIO_LETTURA: + INT 21h ; Lettura di un carattere da tastiera (AH = 01) e memorizzazione del suo codice ASCII in AL + CMP AL, ' ' ; Si scartano gli eventuali spazi o caratteri di controllo presenti prima del numero + JBE INIZIO_LETTURA + +ELABORA_CIFRA: + CMP AL, '0' + JB FINE_LETTURA ; L'elaborazione termina in presenza di un carattere non numerico + CMP AL, '9' + JA FINE_LETTURA + + MOV AH, 0 + SUB AL, '0' ; Il codice ASCII della cifra letta e' convertita un un numero + PUSH AX ; Il registro AX serve per eseguire una moltiplicazione, si conserva quindi + ; il suo valore nello stack + + ; Operazione DX = DX * 10 + AX + MOV AX, DX ; Copio in AX il valore iniziale di DX + MUL DIECI ; Moltiplico AX per 10 .... + MOV DX, AX ; e colloco il risultato in DX + + POP AX ; Si recupera il valore precedentemente collocato nello stack... + ADD DX, AX ; ... e lo si aggiunge a DX + + MOV AH, 01h ; Legge un altro carattere da tastiera + INT 21h + JMP ELABORA_CIFRA + +FINE_LETTURA: + .EXIT +END diff --git a/IO/SCRIVI_I.ASM b/IO/SCRIVI_I.ASM new file mode 100644 index 0000000000000000000000000000000000000000..5d70b9867e2b9c0fcddaf46d18a475c0a0fe789d --- /dev/null +++ b/IO/SCRIVI_I.ASM @@ -0,0 +1,59 @@ +; File: SCRIVI_U.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 17/02/2022 +; +; Descrizione: Scrive su monitor il valore di un numero con segno a 16 bit utilizzando il servizio DOS 21h. +; Il numero da scrivere e' contenuto nel registro DX +; + +TITLE SCRIVI_I +.MODEL SMALL + +.STACK +.DATA + DIECI DW 10 + SEGNO DB '+' +.CODE + .STARTUP + + MOV DX, -32768 + + PUSH AX ; Questi registri saranno modificati dall'algoritmo, e' importante + PUSH CX ; salvare il loro contenuto nello stack + PUSH DX + + MOV CX, 0 ; Contatore delle cifre da stampare + MOV AX, DX + + CMP AX, 0 + JGE ESTRAI_CIFRA + MOV SEGNO , '-' + NEG AX + +ESTRAI_CIFRA: + MOV DX, 0 + DIV DIECI ; Divide DX:AX (un numero a 32 bit) per 10, ponendo il quoziente in AX e il resto in DX + ADD DX, '0' ; Trasforma il resto nel codice ASCII della cifra numerica corrispondente + PUSH DX ; La cifra e' depositata nello stack, sara' recuperata alla fine dell'algoritmo + INC CX + CMP AX, 0 + JNE ESTRAI_CIFRA + + MOV AH, 02h + CMP SEGNO, '-' + JNE STAMPA_CIFRA + MOV DL, SEGNO + INT 21h +STAMPA_CIFRA: + POP DX ; Recupera dallo stack il codice ASCII della cifra da stampare + INT 21h ; Stampa il carattere contenuto in DL + DEC CX + JNZ STAMPA_CIFRA + + POP DX ; Ripristino dei contenuti iniziali dei registri modificati (in ordine inverso) + POP CX + POP AX + .EXIT +END diff --git a/IO/SCRIVI_U.ASM b/IO/SCRIVI_U.ASM new file mode 100644 index 0000000000000000000000000000000000000000..7a3f1e8c9f8f6d4eecbaf57294464104fda79892 --- /dev/null +++ b/IO/SCRIVI_U.ASM @@ -0,0 +1,48 @@ +; File: SCRIVI_U.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 17/02/2022 +; +; Descrizione: Scrive su monitor il valore di un numero senza segno a 16 bit utilizzando il servizio DOS 21h. +; Il numero da scrivere e' contenuto nel registro DX +; + +TITLE SCRIVI_U +.MODEL SMALL + +.STACK +.DATA + DIECI DW 10 +.CODE + .STARTUP + + MOV DX, 0Dh ; Valore di prova + + PUSH AX ; Questi registri saranno modificati dall'algoritmo, e' importante + PUSH CX ; salvare il loro contenuto nello stack + PUSH DX + + MOV CX, 0 ; Contatore delle cifre da stampare + MOV AX, DX +ESTRAI_CIFRA: + MOV DX, 0 + DIV DIECI ; Divide DX:AX (un numero a 32 bit) per 10, ponendo il quoziente in AX e il resto in DX + ADD DX, '0' ; Trasforma il resto nel codice ASCII della cifra numerica corrispondente + PUSH DX ; La cifra e' depositata nello stack, sara' recuperata alla fine dell'algoritmo + INC CX + CMP AX, 0 + JNE ESTRAI_CIFRA + + MOV AH, 02h +STAMPA_CIFRA: + POP DX ; Recupera dallo stack il codice ASCII della cifra da stampare + INT 21h ; Stampa il carattere contenuto in DL + DEC CX + JNZ STAMPA_CIFRA + + POP DX ; Ripristino dei contenuti iniziali dei registri modificati (in ordine inverso) + POP CX + POP AX + .EXIT +END diff --git a/README.md b/README.md index f6e2e6059efd4e67ba16ae5fed9d5fe0c5f3f310..20d0e52d355b03c97508422c18a1f4df80c9da2b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,18 @@ # Esercizi di Assembly 8086 +© 2022 - prof. Roberto Fuligni + Materiale didattico per gli studenti dell'Istituto Tecnico Tecnologico "Giacomo Fauser" di Novara. Soluzioni di alcuni degli esercizi di programmazione in Assembly proposti dal libro di testo "Nuovo Sistemi e reti 1" (editore Hoepli) + +## Soluzioni degli esercizi +1. [Istruzioni di salto](U3L5) (Unità 3 Lezione 5) + +## Routine di Input/Output basate sul sevizio DOS 21h +* ([LEGGI_U.ASM](IO/LEGGI_U.ASM)) - Lettura da tastiera di un numero senza segno a 16 bit +* ([LEGGI_I.ASM](IO/LEGGI_I.ASM)) - Lettura da tastiera di un numero con segno a 16 bit +* ([SCRIVI_U.ASM](IO/SCRIVI_U.ASM)) - Scrittura su monitor di un numero senza segno a 16 bit +* ([SCRIVI_I.ASM](IO/SCRIVI_I.ASM)) - Scrittura su monitor di un numero con segno a 16 bit + diff --git a/U3L6/U3L6ES01.ASM b/U3L6/U3L6ES01.ASM new file mode 100644 index 0000000000000000000000000000000000000000..4ae2b5a4ad09773521e468bfe8f998cdb2f8fcb3 --- /dev/null +++ b/U3L6/U3L6ES01.ASM @@ -0,0 +1,47 @@ +; File: U3L6ES01.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 06/02/2022 +; +; Descrizione: Dato un numero presente nella cella 0100h calcolare i fattori primi +; memorizzandoli a partire dalla cella successiva. +; + +TITLE Esercizio n. 1 pag. 164 +.MODEL SMALL + +.STACK +.DATA + IND_INIZIALE EQU 0100h + +.CODE + .STARTUP + MOV BX, IND_INIZIALE + MOV BYTE PTR [BX], 252 ; 252 = 2 * 2 * 3 * 3 * 7 + + MOV DL, 2 ; Fattore da ricercare + MOV AL, [BX] ; Copia in AL il numero da scomporre + +INIZIO: + CMP AL, 1 + JBE FINE + MOV AH, 0 + MOV CL, AL ; Crea una copia di AL in CL + DIV DL ; Divide AX per DL -> quoziente in AL, resto in AH + CMP AH, 0 ; Il resto è zero? + JE TROVATO ; Se il resto e' zero, DL contiene un fattore + + ; Il registro DL non contiene un fattore, occorre incrementare DL e ripristinare AL + INC DL + MOV AL, CL + JMP INIZIO + +TROVATO: + INC BX + MOV BYTE PTR [BX], DL + JMP INIZIO + +FINE: + .EXIT +END diff --git a/U3L6/U3L6ES04.ASM b/U3L6/U3L6ES04.ASM new file mode 100644 index 0000000000000000000000000000000000000000..bbc002d7d9683bb1e67ff397f70f8310771b5c2e --- /dev/null +++ b/U3L6/U3L6ES04.ASM @@ -0,0 +1,88 @@ +; File: U3L6ES04.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 06/02/2022 +; +; Descrizione: Dopo aver letto da tastiera un numero “n” a 8 bit (al max 10), +; stampare a video una piramide di valori. Ad esempio con un valore di n=7, +; abbiamo i seguenti valori: +; 1 +; 22 +; 333 +; 4444 +; 55555 +; 666666 +; 7777777 +; + +TITLE Esercizio n. 4 pag. 164 +.MODEL SMALL + +.STACK +.DATA + MSG DB 'Inserire un numero tra 1 e 10: ', '$' + ACAPO DB 13, 10, '$' + DIECI DB 10 +.CODE + .STARTUP + + ; Stampa di un messaggio + LEA DX, MSG ; carica in DX l'indirizzo di MSG + MOV AH, 09H + INT 21h + + ; Lettura di una sequenza di caratteri da tastiera e + ; conversione in un numero intero memorizzato in BL + MOV BL, 0 + +LEGGI_CAR: + MOV AH, 01h + INT 21h ; Servizio DOS 01h: Lettura di un carattere da tastiera + CMP AL, 0Dh ; Se AL contiene il carattere CR, si passa alla stampa della piramide + JE PIRAMIDE + PUSH AX ; Copia il carattere digitato nello stack + + ; Conversione di un carattere in una cifra numerica da aggiungere a BL + MOV AL, BL + MUL DIECI + MOV BL, AL ; Equivalente a BL = BL * 10 + POP AX ; Recupera il carattere dallo stack + SUB AL, '0' + ADD BL, AL ; Equivalente a BX = BX + (AL-'0') + JMP LEGGI_CAR + +PIRAMIDE: + MOV CL, 0 ; Contatore di righe stampate + +CICLO_RIGA: + CMP CL, BL ; Confronta il contatore con il numero totale di righe + JE FINE ; Termina se CL = BL + + INC CL + MOV DL, CL ; Calcola il codice ASCII della cifra da stampare + ADD DL, '0' + CMP DL , '9' + JBE INIZIO_RIGA + MOV DL, '0' ; Se la cifra è maggiore di 9, stampa '0' + +INIZIO_RIGA: + PUSH CX ; Salva il contatore nello stack per riutilizzare CL nel ciclo interno + ; Il valore di CL coincide infatti con la lunghezza della riga da stampare +CICLO_CIFRA: + CMP CL, 0 + JE FINE_CIFRA + MOV AH, 02h + INT 21h ; Stampa il carattere presente in DL + DEC CL ; Ripeto per l'intera lunghezza della riga + JMP CICLO_CIFRA + +FINE_CIFRA: + LEA DX, ACAPO + MOV AH, 09h ; Stampa CR + LF + INT 21h + POP CX ; Ripristina il contatore di riga + JMP CICLO_RIGA +FINE: + .EXIT +END diff --git a/U3L6/U3L6ES07.ASM b/U3L6/U3L6ES07.ASM new file mode 100644 index 0000000000000000000000000000000000000000..4c3506366a7140745595dcb69ebbcff6e6d48558 --- /dev/null +++ b/U3L6/U3L6ES07.ASM @@ -0,0 +1,62 @@ +; File: U3L6ES07.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 15/02/2022 +; +; Descrizione: Scrivi un programma Assembly che legga una stringa da tastiera, +; terminante con il carattere dollaro (‘$’), la memorizzi a partire +; dalla cella 0100h, quindi la trasformi in maiuscolo e la stampi a video. +; + +TITLE Esercizio n. 7 pag. 165 +.MODEL SMALL + +.STACK +.DATA + ACAPO DB 0Dh, 0Ah, '$' +.CODE + .STARTUP + + MOV BX, 0100h + MOV SI, 0 + +LEGGI_CAR: + MOV AH, 01h ; Legge un carattere da tastiera e lo memorizza in AL + INT 21h + MOV BYTE PTR [BX+SI], AL + INC SI + CMP AL, '$' + JNE LEGGI_CAR + + MOV DX, OFFSET ACAPO ; Posizione il cursore su una nuova linea + MOV AH, 09h + INT 21h + + ; Converte la stringa letta in maiuscolo + MOV SI, 0 + +CONVERTI_CAR: + MOV AL, [BX+SI] + CMP AL, '$' + JE STAMPA + CMP AL, 'a' + JB CONTINUA + CMP AL, 'z' + JA CONTINUA + ; il carattere e' minuscolo, occorre convertirlo in maiuscolo + SUB AL, 32 + MOV [BX+SI], AL + +CONTINUA: + INC SI + JMP CONVERTI_CAR + +STAMPA: + MOV DX, BX + MOV AH, 09h + INT 21h + +FINE: + .EXIT +END diff --git a/U3L6/U3L6ES08.ASM b/U3L6/U3L6ES08.ASM new file mode 100644 index 0000000000000000000000000000000000000000..283ef6acaffb7c11d52bd2556e2fbad20ea6d9bf --- /dev/null +++ b/U3L6/U3L6ES08.ASM @@ -0,0 +1,107 @@ +; File: U3L6ES08.ASM +; +; Autore: Roberto FULIGNI +; +; Ultima modifica: 15/02/2022 +; +; Descrizione: Scrivi un programma Assembly che dopo aver letto da tastiera N numeri, +; terminanti con il simbolo dollaro (‘$’), li memorizzi a partire dalla cella 0100, +; quindi estragga i soli numeri con indirizzo divisibile per tre e li sommi tra +; di loro, ponendo il risultato a partire dall’indirizzo 0300h +; + +TITLE Esercizio n. 8 pag. 165 +.MODEL SMALL + +.STACK +.DATA + N EQU 6 + DIECI DW 10 + TRE DB 3 + ACAPO DB 0Dh, 0Ah, '$' + MSG1 DB 'Inserire una sequenza di numeri: ', '$' + MSG2 DB 'Somma delle celle (16 bit) avente indirizzo multiplo di tre: ', '$' +.CODE + .STARTUP + MOV BX, 0100h + MOV SI, 0 + MOV CX, N + + MOV DX, OFFSET MSG1 + MOV AH, 09h + INT 21h + +LEGGI_NUM: + MOV DX, 0 ; Il numero letto da tastiera e' memorizzato in DX +LEGGI_CIFRA: + MOV AH, 01h + INT 21h + CMP AL, '$' + JE MEMORIZZA_NUM + MOV AH, 0 + SUB AL, '0' + PUSH AX + MOV AX, DX + MUL DIECI + MOV DX, AX + POP AX + ADD DX, AX + JMP LEGGI_CIFRA +MEMORIZZA_NUM: + MOV [BX+SI], DX + INC SI + INC SI + DEC CX + JNZ LEGGI_NUM + + ; Elaborazione dei dati + MOV CX, N + MOV DX, 0 +ELABORA_NUM: + MOV AX, BX + DIV TRE + CMP AH, 0 + JNE CONTINUA + ADD DX, [BX] +CONTINUA: + INC BX + INC BX + DEC CX + JNZ ELABORA_NUM + + ; Memorizzazione del risultato finale + MOV BX, 0300h + MOV [BX], DX + + ; Stampa del numero contenuto nella cella 0300h + MOV AX, [BX] + MOV CX, 0 +ESTRAI_CIFRA: + MOV DX, 0 + DIV DIECI + ADD DX, '0' + PUSH DX + INC CX + CMP AX, 0 + JA ESTRAI_CIFRA + + MOV DX, OFFSET ACAPO + MOV AH, 09h + INT 21h + MOV DX, OFFSET MSG2 + INT 21h + + +STAMPA_CIFRA: + POP DX + MOV AH, 02h + INT 21h + DEC CX + JNZ STAMPA_CIFRA + + MOV DX, OFFSET ACAPO + MOV AH, 09h + INT 21h + + .EXIT +END