ESEMPI

A supporto utilizza questi link:

http://www.giobe2000.it/Tutorial/Schede/07-IstruzioniCpu/703.asp
http://www.shsu.edu/~csc_tjm/spring2005/cs272/intro_to_asm.html
 

Costruire un programma che visualizza il numero di caratteri scritti nella stringa dei parametri.

Prima di procedere vediamo un pò di teoria

Il PSP  (prefisso del segmento di programma) è un'area di memoria di 256 bytes (100h) collocata all'inizio del code segmento (area di memoria destinata, dal loader del dos, al codice del programma eseguibile.

Le ultime 128 locazioni del PSP (da 0080H a 00FFH) sono usate dal Dos per 2 funzioni molto specifiche:
- come Buffer temporaneo di default per i dati da trasferire da e verso un disco: quest'area è significativa solo con le (obsolete) funzioni DOS che gestiscono i files mediante la tecnica dei File Control Block; in questo caso questa zona assume il nome di Area di Trasferimento per il Disco (DTA, Disk Transfer Area).
- come area di memoria per la stringa dei parametri eventualmente passati al nostro programma sulla linea di comando; In particolare il primo byte (all'indirizzo 0080H) contiene la lunghezza della coda del comando (cioè il numero di caratteri della stringa dei parametri) aumentata di 1.

SOLUZIONE:

a.1) Se pongo a 9 il limite del numero di caratteri presente nella stringa dei parametri la soluzione risulta molto semplice:

C:\asm>debug
-a
181B:0100 MOV AH,02
181B:0102 MOV DL,[0080]
181B:0106 ADD DL,30
181B:0109 INT 21
181B:010B RET
181B:010C
-r bx
BX 0000
:0
-r cx
CX 0000
:c
-n soluz1.com
-w
Writing 0000C bytes
-q
C:\asm>soluz1
0
C:\asm>soluz1 ciao
5
C:\asm>soluz1 ciao caio
:
C:\asm>

a.2) La stessa soluzione poteva essere proposta utilizzando il pacchetto di procedure del BIOS relative al video noto come interrupt 10h.

Ricordo che:

- l'interrupt 10h contiene le procedure del BIOS relative al video,

- l'interrupt 14h contiene le procedure del BIOS relative alla porta seriale,

- l'interrupt 17h contiene le procedure del BIOS relative alla porta parallela e stampante

- l'interrupt 21h contiene le procedure di sistema a livello DOS. Sono decisamente più numerose ma in questa pagina sono citate quelle più importanti.

Maggiori dettagli possono essere trovati all'indirizzo:
http://www.giobe2000.it/Tutorial/LivelloBios/LivelloBios01.asp

C:\asm>debug
-a
182C:0100 MOV AL,[0080]
182C:0103 ADD AL,30
182C:0105 MOV AH,0E
182C:0107 INT 10
182C:0109 RET
182C:010A
-r bx
BX 0000
:0
-r cx
CX 000A
:A
-n soluz1v.com
-w
Writing 0000A bytes
-q

C:\asm>soluz1v
0
C:\asm>soluz1v arrivederci
<
C:\asm>soluz1v ciao
5
C:\asm>

a.3) Altra soluzione era quella di scrivere direttamente nella RAM video il carattere da visualizzare.

Prima di procedere vediamo un pò di teoria

La Ram Video è posta nel primo megabyte della zona della memoria convenzionale di Sistema; la sua dimensione è di 128kBytes, a partire dall’indirizzo fisico A0000H fino all’indirizzo fisico BFFFFH; la pratica della programmazione a basso livello consente di esprimere questi indirizzi fisici nei corrispondenti indirizzi logici, da A000:0000 a B800:7FFF (un indirizzo logico si esprime sempre nella forma Segmento:Offset).

Questa area di memoria è a sua volta divisa in 3 parti:
- nella prima (da A000:0000 a A000:FFFF) trovano posto i 64K bytes destinati alla gestione del video in Modo Grafico. L'unità di informazione è il pixel (semplificando ogni pixel può essere descritto con un byte (8 bit) quando assume 2⁸=256 colori . Lo stesso byte può essere usato per descrivere otto pixel ma in questo caso ogni pxel può assumere solo 2 colori, bianco o nero, cioè acceso o spento).
- nella seconda (da B000:0000 a B000:7FFF) sono disponibili i 32K bytes dedicati al modo Monocromatico, ormai in disuso.
- nell'ultima parte (da B000:8000 a B000:FFFF) sono allocati i 32K bytes necessari alla gestione del video in Modo Testo. L'unità di informazione è il carattere (vedremo che per descrivere le caratteristiche di ogni carattere saranno necessari 2 byte: simbolo ascii + colore).

Quando si lavora in Modo Testo la zona di Ram Video che ci interessa è quella compresa tra B000:8000 e B000:FFFF (32Kbyte in tutto); poiché la tecnica della segmentazione della memoria ci consente di esprimere il medesimo indirizzo logico in molti modi diversi, per motivi di opportunità conviene modificare il contenuto Segment:Offset di questo intervallo, trasformandolo in B800:0000 - B800:7FFF.

I 32 kBytes della Ram Video destinata al Modo Testo sono divisi in 8 zone uguali, dette Pagine Video, ciascuna di 4 kBytes (4096 bytes).
Ciascuna delle 8 Pagine Video, numerate da 0 a 7, copre quindi l'area di memoria Ram corrispondente agli indirizzi:

a.3) Sulla base delle considerazioni enunciate la soluzione diventa:

C:\asm>debug<soluz1rv.asm
-a
1810:0100 ; --- LEGGO POSIZIONE CURSORE
1810:0100 MOV AH,3
1810:0102 MOV BH,0
1810:0104 INT 10
1810:0106 ; --- CALCOLO LA CELLA DI MEMORIA
1810:0106 MOV AX,A0
1810:0109 XOR DL,DL
1810:010B MUL DH
1810:010D ; --- RIPOSIZIONO L'EXTENDED DATA
1810:010D ; --- SEGMENT SULLA RAM VIDEO
1810:010D MOV CX,B800
1810:0110 MOV ES,CX
1810:0112 MOV SI,AX
1810:0114 ; --- SCRIVO IL NUMERO
1810:0114 ; --- NELLA RAM VIDEO B800:SI
1810:0114 MOV AL,[0080]
1810:0117 ADD AL,30
1810:0119 MOV AH,7
1810:011B ES:MOV [SI],AX
1810:011E RET
1810:011F
-n soluz1rv.com
-r bx
BX 0000
:0
-r cx
CX 0000
:1F
-w
Writing 0001F bytes
-q

C:\asm>soluz1rv
0
C:\asm>soluz1rv arrivederci
<
C:\asm>soluz1rv ciao
5
C:\asm>

b) Se il numero di caratteri nella stringa dei parametri può superare i dieci allora la soluzione diventa più complessa:

C:\asm>debug
a
1836:0100 MOV DL,A
1836:0102 XOR CX,CX
1836:0104 XOR AH,AH
1836:0106 MOV AL,[0080]
1836:0109 ;---------- INIZIO: 0109
1836:0109 DIV DL
1836:010B ADD AH,30
1836:010E PUSH AX
1836:010F XOR AH,AH
1836:0111 INC CX
1836:0112 CMP AL,0
1836:0114 JNZ 0109
1836:0116 ;---------- STAMPA:  0116
1836:0116 POP AX
1836:0117 MOV DL,AH
1836:0119 MOV AH,2
1836:011B INT 21
1836:011D DEC CX
1836:011E CMP CX,0
1836:0121 JNZ 0116
1836:0123 RET
1836:0124
-r bx
BX 0000
:0
-r cx
CX 000A
:24
-n soluz1b.com
-w
Writing 0000A bytes
-q

C:\asm>soluz1v
0
C:\asm>soluz1v arrivederci
<
C:\asm>soluz1v ciao
5
C:\asm>

C:\asm>debug
-a
181B:0100 XOR AH,AH
181B:0102 MOV AL,[0080]
181B:0105 MOV SI,0080
181B:0108 ADD SI,AX
181B:010A ;---------- INIZIO STAMPA: 010A
181B:010A CMP SI,0081
181B:010E JL 119
181B:0110 MOV DL,[SI]
181B:0112 MOV AH,2
181B:0114 INT 21
181B:0116 DEC SI
181B:0117 JMP 010A
181B:0119 ;---------- FINE PROGRAMMA: 0119
181B:0119 RET
181B:011A
-r bx
BX 0000
:0
-r cx
CX 0000
:1A
-n inverte.com
-w
Writing 0001A bytes
-q
C:\asm>inverte ciao marco
ocram oaic
C:\asm>inverte

C:\asm>

Costruire un programma "Saluta" che stampa la parola "Ciao" un numero di volte pari al valore indicato sulla stringa degli argomenti (esempio: Saluta 3 ==> "Ciao|Ciao|Ciao|")
 

SOLUZIONE:

La soluzione suggerita gestisce l'assenza di parametri ma non la casistica non numerica

C:\asm>debug
-a
181B:0100 MOV DL,[0080]
181B:0104 XOR DH,DH
181B:0106 MOV SI,0082
181B:0109 XOR AX,AX
181B:010B MOV CL,A
181B:010D DEC DL
181B:010F ;---- INIZIO ESTRAZIONE: 010F
181B:010F CMP DL,0
181B:0112 JLE 0124
181B:0114 MUL CL
181B:0116 MOV BL,[SI]
181B:0118 SUB BL,30
181B:011B XOR BH,BH
181B:011D ADD AX,BX
181B:011F INC SI
181B:0120 DEC DL
181B:0122 JMP 010F
181B:0124 MOV BX,AX
181B:0126 MOV AH,9
181B:0128 ;---------- INIZIO STAMPA: 0128
181B:0128 CMP BX,0
181B:012B JZ 135
181B:012D MOV DX,0136
181B:0130 INT 21
181B:0132 DEC BX
181B:0133 JMP 128
181B:0135 ;---------- FINE PRG: 0135
181B:0135 RET
181B:0136 DB 'Ciao|$'
181B:013C
-n saluta.com
-r bx
BX 0000
:0
-r cx
CX 0000
:3C
-w
Writing 0003C bytes
-q
C:\asm>saluta 3
Ciao|Ciao|Ciao|
C:\asm>saluta

C:\asm>

Costruire un programma Numeri che elimina i caratteri non numerici dalla  stringa dei parametri. La sezione che legge l'argomento deve essere inglobata in una procedura

C:\asm>debug
-a
1810:0100 ; --- PROC LETTURA PARAMETRO
1810:0100 CALL 250
1810:0103 ; --- ESTRAI NUMERI
1810:0103 CALL 350
1810:0106 ; --- LI STAMPO
1810:0106 MOV AH,9
1810:0108 MOV DX,0300
1810:010B INT 21
1810:010D RET
1810:010E ;--- FINE MAIN: 010E
-
-f 0115 024F 0
-a 0200
180E:0200 ;--- COPIA STRINGA PARAMETRI
180E:0200 ;--- NEL BUFFER 30 BYTE: 200F
180E:0200 DB '                              '
180E:021E
-
-a 0250
1810:0250 PUSH AX
1810:0251 PUSH SI
1810:0252 PUSH DI
1810:0253 ;--- INIZIALIZZAZIONE: 0253
1810:0253 MOV AL,[0080]
1810:0256 MOV SI,0082
1810:0259 MOV DI,0200
1810:025C DEC AL
1810:025E ;--- SCORRO STRINGA: 025E
1810:025E CMP AL,0
1810:0260 JLE 026C
1810:0262 MOV AH,[SI]
1810:0264 MOV [DI],AH
1810:0266 INC SI
1810:0267 INC DI
1810:0268 DEC AL
1810:026A JMP 025E
1810:026C ;--- CHIUSURA: 026C
1810:026C MOV AH,24
1810:026E MOV [DI],AH
1810:0270 POP DI
1810:0271 POP SI
1810:0272 POP AX
1810:0273 RET
1810:0274 ;--- CHIUSURA: 0273
1810:0274
-
-f 0274 034F 0
-a 0300
1810:0300 ;--- ESTRAI NUMERI
1810:0300 ;--- NEL BUFFER 30 BYTE: 300F
1810:0300 DB '                              '
1810:031E
-
-a 0350
1810:0350 PUSH AX
1810:0351 PUSH SI
1810:0352 PUSH DI
1810:0353 MOV SI,0200
1810:0356 MOV DI,0300
1810:0359 ;--- INIZIALIZZAZIONE: 0356
1810:0359 MOV AH,[SI]
1810:035B CMP AH,24
1810:035E JE 0375
1810:0360 CMP AH,2D
1810:0363 JE 036F
1810:0365 CMP AH,39
1810:0368 JA 0372
1810:036A CMP AH,30
1810:036D JB 0372
1810:036F ;--- REGISTRA 036F
1810:036F MOV [DI],AH
1810:0371 INC DI
1810:0372 ;--- SUCCESSIVO 0372
1810:0372 INC SI
1810:0373 JMP 0359
1810:0375 ;--- CHIUSURA: 375
1810:0375 MOV [DI],AH
1810:0377 POP DI
1810:0378 POP SI
1810:0379 POP AX
1810:037A RET
1810:037B ;--- CHIUSURA: 037B
1810:037B

-n numeri.com
-r bx
BX 0000
:0
-r cx
CX 0000
:37B
-w
Writing 0027B bytes
-q

C:\asm>numeri c1i2a3o4
1234
C:\asm>numeri ciao

C:\asm>numeri 123
123
C:\asm>

Costruire un programma "cursore" che legge la posizione del cursore nel video, lo pulisce e poi scrive al centro del video le coordinate.

C:\asm>debug
-a
1810:0100 ;--- LEGGO LA POSIZIONE CURSORE
1810:0100 MOV AH,3
1810:0102 MOV BH,0
1810:0104 INT 10
1810:0106 ;--- MEMORIZZO LE COORDINATE
1810:0106 PUSH DX
1810:0107 ;--- PULISCE LO SCHERMO E IMPOSTA
1810:0107 ;--- MODE TTY 25x80
1810:0107 ; MOV AL,2 - ;MOV AH,0
1810:0107 MOV AX,0002
1810:010A INT 10
1810:010C ;--- POSIZIONO CURSORE: R.5-C.32
1810:010C MOV DX,0520
1810:010F CALL 300
1810:0112 ;--- AGGIUNGO A "COLONNA: ___"
1810:0112 ;--- LA COORDINATA RELATIVA
1810:0112 POP DX
1810:0113 MOV SI,020B
1810:0116 CALL 250
1810:0119 PUSH DX
1810:011A ;--- STAMPA LA COLONNA
1810:011A MOV AH,9
1810:011C MOV DX,0200
1810:011F INT 21
1810:0121 ;--- POSIZIONO CURSORE: R.5-C.32
1810:0121 MOV DX,0620
1810:0124 CALL 300
1810:0127 ;--- AGGIUNGO ALLA STRINGA "RIGA: ___"
1810:0127 ;--- LA COORDINATA RELATIVA
1810:0127 POP DX
1810:0128 MOV DL,DH
1810:012A MOV SI,0218
1810:012D CALL 250
1810:0130 ;--- STAMPA LA RIGA
1810:0130 MOV DX,020D
1810:0133 INT 21
1810:0135 RET
1810:0136
-a 200
1810:0200 ; --- DS:0200
1810:0200 DB 'Colonna: ___$'
1810:020D ; --- DS:020D
1810:020D DB 'Riga:    ___$'
1810:021A
-a 250
1810:0250 ; PROCEDURA 250: AGGIUNGE LA
1810:0250 ; COORDINATA ALLA STRINGA DI OUTPUT
1810:0250 PUSH AX
1810:0251 PUSH DX
1810:0252 PUSH SI
1810:0253 MOV AL,DL
1810:0255 XOR AH,AH
1810:0257 MOV DL,A
1810:0259 ; LOOP 259
1810:0259 DIV DL
1810:025B ADD AH,30
1810:025E MOV [SI],AH
1810:0260 XOR AH,AH
1810:0262 DEC SI
1810:0263 CMP AL,0
1810:0265 JNZ 0259
1810:0267 POP SI
1810:0268 POP DX
1810:0269 POP AX
1810:026A RET
1810:026B
-a 300
1810:0300 ; PROCEDURA 300: POSIZIONA IL
1810:0300 ; CURSORE AH: RIGA - AL: COLONNA
1810:0300 PUSH AX
1810:0301 PUSH BX
1810:0302 PUSH DX
1810:0303 MOV BH,0
1810:0305 MOV AH,2
1810:0307 ; Colonna: MOV DL,20
1810:0307 ; Riga:  : MOV DH,5
1810:0307 INT 10
1810:0309 POP DX
1810:030A POP BX
1810:030B POP AX
1810:030C RET
1810:030D
-n cursore.com
-r bx
BX 0000
:0
-r cx
CX 0000
:20D
-w
Writing 0020D bytes
-q

C:\asm>

Prima di procedere vediamo un pò di teoria

Un PIT  (programmable interval timer) è un contatore che emette un interrupt quando esso raggiunge un determinato valore.  L'Intel 8253 e la sua evoluzione l'8254 sono dei PIT, che svolgono funzioni di temporizzazione e conteggio. Essi o equivalenti sono installati in tutti i PC IBM compatibili. I PIT vengono utilizzati per:

• Generare dei ritardi sotto il controllo software
• Generare dei segnali (onde quadre, impulsi) con frequenza programmabile
• Contatore di eventi
• Misuratore di intervalli
• Divisore di frequenza.
 

L'8253 ha 3 contatori chiamati canali. Ogni canale può essere programmato per operare in 6 modi. Una volta programmato, i canali svolgono la loro attività in maniera indipendente. Al timer viene assegnato l'IRQ-0 (che corrisponde all'interrupt hardware a più alta priorità) per l'alto livello di criticità svolto e perchè molte device dipendono da esso. I 3 contatori da 16 bit (identificati con counter 0, counter 1, counter 2 e selezionati mediante i pin A0 e A1) hanno 2 pin di input (Clock e Gate) e un pin di Output.
 

Nei primi PC IBM il primo contatore (A0=0 e A1=0) era utilizzato per la gestione dell'orario, il secondo (A1=0, A0=1) per innescare il refresh della DRAM mentre il terzo (A1=1, A0=0) per generare suoni tramite lo speaker del PC. Gli indirizzi dei contatori 0, 1 e 2 sono rispettivamente 40h, 41h e 42h
 

Il microchip 8253 contiene un Data/Bus Buffer che è costituito da un buffer bidirezionale di 8 bit che può assumere il valore 3-state. E' composto da 8 pin etichettati con D0...D7 (D7 è il bit + significativo) collegati al Data Bus del sistema. Il Data Bus è utilizzato principalmente per:

• programmare l’8253 (definendo il modo di funzionamento per ogni contatore)
• inizializzare i contatori
• leggere i valori dei contatori.

Il microchip viene programmato agendo sul Registro di Controllo (A1=1, A0=1) del dispositivo scegliendo tra 6 modi diversi di funzionamento. Il Registro di controllo ha indirizzo 43h. Quando il registro di controllo viene impostato i contatori vengono resettati a 0000h. Il microchip viene attivato tramite il segnale CS. Quindi l’8253 è programmabile via software. Un insieme di parole di controllo devono essere scritte dalla CPU per inizializzare ciascun contatore. Prima dell’inizializzazione, il modo di funzionamento, il contenuto e l’uscita di ogni contatore sono indefiniti.
Quindi per ciascun contatore, il valore nel Registro di Controllo determina:

• il modo di funzionamento
• le modalità di caricamento del valore di inizializzazione
• il tipo di conteggio (binario o BCD).
 

La codifica Binary-coded decimal (BCD) è un modo comunemente utilizzato in informatica ed elettronica per rappresentare le cifre decimali in codice binario.
In questo formato ogni cifra di un numero è rappresentata da un codice binario di quattro bit, il cui valore è compreso tra 0 (0000) e 9 (1001). Il codice BCD è molto usato in elettronica, specialmente in circuiti digitali privi di microprocessore, perché facilita la visualizzazione di lunghe cifre su display a sette segmenti, infatti ad ogni display fisico corrisponde esattamente una cifra.

Le operazioni di input/output sono riassunte in questa tabella:
 

mentre i 6 modi di funzionamento sono:

Nel modo 0 il conteggio parte non appena termina l'operazione di caricamento del contatore. Durante il conteggio il pin di OUT resta basso. Al termine diventa alto e ci resta fino al caricamento di un nuovo valore. Il pin GATE abilita il conteggio quando è alto, lo disabilita quando è basso.

Nel modo 1 il conteggio inizia in corrispondenza del fronte di salita di GATE. Il conteggio non inizia quindi con l'operazione di caricamento del contatore. Durante il conteggio OUT resta basso, altrimenti è alto. Se nel contatore viene caricato un nuovo valore , questo non modifica il conteggio in corso, ma quello successivo. Se si ha un fronte di salita di GATE durante il conteggio, il conteggio viene fatto ripartire da capo. L'operazione di WR rappresenta l'operazione di caricamento del contatore.
 

Nel modo 2 il contatore funziona come divisore di frequenza. Ogni n cicli (n è il valore del counter) su CLK, OUT resta basso per un ciclo. Il conteggio parte al caricamento del contatore; un nuovo caricamento non interessa il conteggio in corso, ma il successivo. Quando il segnale di GATE è basso, OUT rimane fisso al valore alto e il contatore rimane fisso; il successivo fronte di salita fa ripartire il conteggio da capo.

Verrà descritto il modo in cui all’interno di un PC è connesso lo speaker, e come il suo funzionamento possa essere programmato via software.

Su un IBM-PC  il canale 2 del timer è connesso, tramite una porta AND, allo speaker del computer.

Lo starter del timer è connesso al bit 0 della porta 61h (SPEAKER DATA). Mandando 1 a tale bit della porta implica l'attivazione del timer. Se la modalità è un'onda quadra (mode 3) allora tale segnale verrà inviato (tramite il canale 2) come input alla porta AND che alimenta lo speaker. L'altro input della porta AND è rappresentato dal bit 1 della porta 61h (chiamato GATE2). La frequenza dell'onda quadra è determinato da come il timer è stato programmato.

Il canale 2 del timer (contatore 2 dell'8253) è connesso tramite una porta AND allo speaker del computer.

Lo starter del timer è connesso al bit 0 della porta 61h (SPEAKER DATA). Mandando 1 a tale bit della porta implica l'attivazione del timer. Se la modalità è un'onda quadra (mode 3) allora tale segnale verrà inviato (tramite il canale 2) come input alla porta AND che alimenta lo speaker. L'altro input della porta AND è rappresentato dal bit 1 della porta 61h (chiamato GATE2). La frequenza dell'onda quadra è determinato da come il timer è stato programmato.

ù

Il computer ha uno speaker interno che è in grado di generare dei beep a diversa frequenza. Essendo la frequenza rappresentata da un numero a 16 bit segue che è possibile generare una qualsiasi frequenza dal 18,21hz (se vale 65.535) a 1.193.180 hz (se vale 1).  Le frequenze abbinate alle 7 note nell'ottava centrale del pianoforte sono: DO 261,7 Hz (4560) - RE 293,7 Hz (4063) - MI 329,6 Hz (3619)- FA 349,2 Hz (3416) - SOL 391,0 Hz (3043) - LA 440,0 Hz  (2711) - SI 493,9 Hz  (2415).

Costruire un programma che inizializza i 3 contatori del microchip 8253 in questo modo:

• Contatore 0: Conteggio Binario, modo 0 con valore iniziale 1234H
• Contatore 1: Conteggio BCD, modo 2 con valore iniziale 100H
• Contatore 2: Conteggio Binario, modo 4 con valore iniziale 1FFFH.

SOLUZIONE:

Partiamo con il primo contatore e consideriamo il registro di controllo:

Per selezionare il counter 0 devo porre SC1 e SC0 uguale entrambe a 0. Il modo richiesto è 0 per cui M2,M1 e M0 devono essere posti a 0. Essendo richiesto il conteggio binario nel bit BCD devo mettere 0.  Poiché devo caricare il valore 1234h che richiede 2 byte imposto RL1 e RL0 entrambe a 1. In questo modo posso impostare prima il byte meno significativo e poi quello più significativo. Il registro di controllo deve essere quindi inizializzato a 00110000 che corrisponde a 30h. Tenendo presente che il registro di controllo ha indirizzo 43h e il contatore 0 l'indirizzo 40h ne consegue:

   ; Contatore 0 - modo 0 - conteggio binario - valore iniziale 1234h
   MOV AL, 30     ; Imposto il registro di controllo
   OUT 43, AL
   MOV AL, 34     ; Carico il byte meno significativo
   OUT 40, AL
   MOV AL, 12     ; Carico il byte più significativo
   OUT 40, AL     

Per selezionare il counter 1 devo porre SC1=0 e SC0=1. Il modo richiesto è 2 per cui pongo M2=0,M1=1 e M0=0 . Essendo richiesto il conteggio BCD nel bit BCD devo mettere 1.  Considerando che i contatori vengono resettati durante la scrittura del registro di controllo per caricare 100h mi basta impostare solo il byte più significativo (MSB). Quindi imposto RL1=1 e RL0=0. Il registro di controllo deve essere quindi inizializzato a 01100101 che corrisponde a 75h. Tenendo presente che il registro di controllo ha indirizzo 43h e il contatore 1 l'indirizzo 41h ne consegue:

   ; Contatore 1 - modo 2 - conteggio BCD - valore iniziale 100h
   MOV AL, 65     ; Imposto il registro di controllo
   OUT 43, AL
   MOV AL, 1     ; Carico il byte più significativo
   OUT 41, AL

Per selezionare il counter 2 devo porre SC1=1 e SC0=0. Il modo richiesto è 4 per cui pongo M2=1,M1=0 e M0=0 . Essendo richiesto il conteggio binario nel bit BCD devo mettere 0.  Poiché devo caricare il valore 01FFh che richiede 2 byte imposto RL1 e RL0 entrambe a 1. In questo modo posso impostare prima il byte meno significativo e poi quello più significativo. Il registro di controllo deve essere quindi inizializzato a 10111000 che corrisponde a 30h. Tenendo presente che il registro di controllo ha indirizzo 43h e il contatore 1 l'indirizzo 41h ne consegue:

   ; Contatore 2 - modo 4 - conteggio Binario - valore iniziale 01FFh
   MOV AL, B8     ; Imposto il registro di controllo
   OUT 43, AL
   MOV AL, FF     ; Carico il byte meno significativo
   OUT 42, AL
   MOV AL, 1F     ; Carico il byte più significativo
   OUT 42, AL     

Si programmi un 8253 in modo da generare un ritardo di 5 msec. Si supponga di avere a disposizione un clock da 1 Mhz.

SOLUZIONE:

Con un Mhz il ciclo di clock è 1 microsecondo per cui per avere un ritardo di 5 millisecondi devo far trascorrere 5000 cicli di clock. Determiniamo come settiamo il registro di controllo. Immaginiamo di utilizzare il contatore 1

Per selezionare il counter 1 devo porre SC1=0 e SC0=1. Il modo richiesto è 0 per cui M2,M1 e M0 devono essere posti a 0. Se utilizzo il conteggio BCD posso inizializzare il contatore a 0101 0000 0000 0000 ovvero a 5000h. Imposto quindi il conteggio BCD per cui nel bit BCD devo mettere 1.  Poiché devo caricare il valore 50h nel byte più significativo e tenendo conto che i contatori vengono resettati durante la scrittura del registro di controllo mi basta impostare imposto RL1=1 e RL0=0 (scrittura/lettura MSB). Il registro di controllo deve essere quindi inizializzato a 01100001 che corrisponde a 61h. Tenendo presente che il registro di controllo ha indirizzo 43h e il contatore 0 l'indirizzo 40h ne consegue:

   ; Contatore 1 - modo 0 - conteggio BC - valore iniziale 5000h
   MOV AL, 61     ; Imposto il registro di controllo
   OUT 43, AL
   MOV AL, 50     ; Carico il byte più significativo
   OUT 42, AL

Costruire un programma che genera un beep la cui durata è determinata da un doppio loop di 16x65535 cicli. La gestione dello speaker deve avvenire utilizzando le istruzioni IN e OUT

SOLUZIONE:

C:\asm>debug
-a
-a
180E:0100 ; Setup speaker
180E:0100 MOV AL,B6
180E:0102 OUT 43,AL
180E:0104 ; Imposto la frequenza
180E:0104 MOV AX,11D0
180E:0107 OUT 42,AL
180E:0109 MOV AL,AH
180E:010B OUT 42,AL
180E:010D ; Attivo il beep
180E:010D IN AL,61
180E:010F OR AL,3
180E:0111 OUT 61,AL
180E:0113 ; Doppio Loop
180E:0113 MOV BX,0010
180E:0116 ; CS:0116
180E:0116 MOV CX,FFFF
180E:0119 ; CS:0119
180E:0119 DEC CX
180E:011A JNZ 0119
180E:011C DEC BX
180E:011D JNZ 0116
180E:011F ; Spengo il beep
180E:011F IN AL,61
180E:0121 AND AL,FC
180E:0123 OUT 61,AL
180E:0125 RET
180E:0126
-r bx
BX 0000
:0
-r cx
CX 0000
:23
-n sound.com
-w
Writing 0000C bytes
-q
C:\asm>sound

C:\asm>

Costruire la procedura beep, che riceve in DI la frequenza in Hz, ed in BX la durata in centesimi di
secondo del suono desiderato.
 

C:\asm>debug
-a
-a
180E:0100 ; Setup speaker
180E:0100 MOV AL,B6
180E:0102 OUT 43,AL
180E:0104 ; Imposto la frequenza
180E:0104 MOV AX,11D0
180E:0107 OUT 42,AL
180E:0109 MOV AL,AH
180E:010B OUT 42,AL
180E:010D ; Attivo il beep
180E:010D IN AL,61
180E:010F OR AL,3
180E:0111 OUT 61,AL
180E:0113 ; Doppio Loop
180E:0113 MOV BX,0010
180E:0116 ; CS:0116
180E:0116 MOV CX,FFFF
180E:0119 ; CS:0119
180E:0119 DEC CX
180E:011A JNZ 0119
180E:011C DEC BX
180E:011D JNZ 0116
180E:011F ; Spengo il beep
180E:011F IN AL,61
180E:0121 AND AL,FC
180E:0123 OUT 61,AL
180E:0125 RET
180E:0126
-r bx
BX 0000
:0
-r cx
CX 0000
:23
-n sound.com
-w
Writing 0000C bytes
-q
C:\asm>sound

C:\asm>

Costruire un programma "leggi" che legge i primi 80 byte del file c:\sechi.txt e lo stampa a video

Prima di procedere vediamo un po' di teoria

Per scrivere la soluzione è necessario ricorrere alle Funzioni DOS che si affidano ai gestori (handle). Sono numerose e, di norma, destinate alla gestione dei files; appartengono a questa serie la Funzione 3CH (per "creare"), la Funzione 3DH (per "aprire"), la Funzione 3EH (per "chiudere"), la Funzione 3FH (per "leggere") e la Funzione 40H (per "scrivere").

In altri termini, con questa tecnica il DOS tratta allo stesso modo (virtualizza) sia i principali dispositivi con cui ha a che fare (CON, COM, ERR) che i files presenti nelle cartelle delle memorie di massa (ai quali assegna i gestori successivi, di numero maggiore o uguale a 5), trattandoli come semplici oggetti da aprire, leggere o scrivere, chiudere.

Questa funzione DOS permette di creare un file. I registri in ingresso coinvolti sono:
AH: che viene posto a 3CH proprio per richiamare la funzione di creazione.
CX: viene impostato con i flag relativi agli attirbuti del file:
    BIT 0 = 1 READ-ONLY
    BIT 1 = 1 HIDDEN FILE
    BIT 2 = 1 SYSTEM FILE
    BIT 3 = 1 VOLUME (IGNORED)
    BIT 4 = 1 RESERVED (0)- DIRECTORY
    BIT 5 = 1 ARCHIVE BIT
    BIT 6 TO 15 RESERVED (0)
DX: indica l'indirizzo logico dell'area di memoria dove si trova il nome del file. Il nome deve terminare con il carattere '\0'.
Il registro coinvolto in uscita è AX . Esso contiene il descrittore (handle) associato al file creato. Il flag CF (carry flag) contiene 0 se la funzione è terminata con successo altrimenti se CF contiene 1 allora si è verificato un errore e in AX viene inserito il codice di errore:
03h: path not found
04h: handle non disponibile
05h: accesso negato

Questa funzione DOS permette di aprire un dispositivo restituendone il descrittore. I registri in ingresso coinvolti sono:
AH: che viene posto a 3DH proprio per richiamare la funzione di apertura - AL a 00.
AL: contiene i flag relativi alla modalità di apertura.
Dal bit 0 al bit 2 la modalità di accesso: 000: read only - 001: write only - 010: read and write
Dal bit 4 al bit 6 la modalità di condivisione: 000: compatibility mode - 001: deny all - 010: dedy write - 011: deny read - 100 deny none.
DX: indica l'indirizzo logico dell'area di memoria dove si trova il nome del file. Il nome deve terminare con il carattere '\0'.
Il registro coinvolto in uscita è AX . Esso contiene il descrittore (handle) associato al file aperto. Il flag CF (carry flag) contiene 0 se la funzione è terminata con successo altrimenti se CF contiene 1 allora si è verificato un errore e in AX viene inserito il codice di errore:

01H MISSING FILE SHARING SOFTWARE
02H FILE NOT FOUND
03H PATH NOT FOUND/ FILE DOESN'T EXIST
04H NO HANDLE AVAILABLE
05H ACCESS DENIED
0CH ACCESS MODE NOT PERMITTED
 

Questa funzione DOS permette di chiudere un dispositivo il cui descrittore è inserito nel registro BX.
 il descrittore. I registri in ingresso coinvolti sono:
AH: che viene posto a 3EH proprio per richiamare la funzione di chiusura - AL a 00.
BX: contiene il descrittore del file o del dispositivo da chiudere.
Se CF contiene 0 allora la funzione ha avuto successo altrimenti  se vale 1 in AX viene messo il codice di errore: 06h: file non aperto/gestore non autorizzato. Attenzione se uso come handle lo zero chiudo lo STDIN per cui non potrò inserire più niente da tastiera.

Questa funzione DOS permette di leggere uno o più bytes in un file o in un dispositivo, inserendoli in un buffer. I registri in ingresso coinvolti sono:
AH: che viene posto a 3FH proprio per richiamare la funzione di lettura
BX: indica il numero del gestore (handle) coinvolto:
    0000=handle 0, associato al dispositivo standard d'ingresso, tastiera, CON
    0002=handle 2, associato al dispositivo standard d'errore, errore, ERR
    0003=handle 3, associato al dispositivo standard ausiliario, seriale, AUX, COM
    0005=handle 5, primo gestore da associare ad un file attualmente aperto
CX: indica il numero di bytes da leggere
DS:DX: indica l'indirizzo logico dell'area di memoria (buffer) in cui salvare i bytes.

Il registro coinvolto in uscita è AX . Esso contiene (se CF=0) il numero di bytes effettivamente letti, consentendo una eventuale verifica a posteriori. Se CF=1 allora in AX  ho il codice d'errore (05h: accesso negato - 06h: handle illegale, file non aperto) che consente di risalire alla causa del mancato funzionamento. Se AX=0 e CF=0 significa che sono arrivato alla fine del file e non ci sono più dati da leggere.

Questa funzione DOS permette di scrivere uno o più bytes in un file o in un dispositivo, prelevandoli da un bufferl. I registri in ingresso coinvolti sono:
AH: viene posto a 40H per richiamare la funzione di scrittura
BX: indica il numero del gestore (handle) coinvolto:
    0001=handle 1, associato al dispositivo standard d'uscita, video, CON
    0002=handle 2, associato al dispositivo standard d'errore, errore, ERR
    0003=handle 3, associato al dispositivo standard ausiliario, seriale, AUX, COM
    0004=handle 4, associato al dispositivo standard di stampa, stampante, PRN
    0005=handle 5, primo gestore da associare ad un file attualmente aperto
CX: indica il numero di bytes da scrivere
DS:DX: indica l'indirizzo logico dell'area di memoria (buffer) da cui prelevare i bytes da scrivere.

In uscita usa AX dove lascia (se CF=0) il numero di bytes effettivamente scritti, consentendo una eventuale verifica a posteriori:
mentre se CF=1 mette in AX il codice d'errore che consente di risalire alla causa del mancato funzionamento.

Questa funzione DOS permette di leggere una stringa di bytes da un dispositivo di tipo "carattere", inserendola in un buffer. L'effetto di questa SottoFunzione è sostanzialmente identico a quello della Funzione 3FH. I registri in ingresso coinvolti sono:
AH: è posto a 44H
AL: è posto a 02H
BX: indica il numero del gestore (handle) coinvolto:
    0000=handle 0, associato al dispositivo standard d'ingresso, tastiera, CON
    0002=handle 2, associato al dispositivo standard d'errore, errore, ERR
    0003=handle 3, associato al dispositivo standard ausiliario, seriale, AUX, COM
    0005=handle 5, primo gestore da associare ad un file attualmente aperto
CX: indica il numero di bytes della stringa da leggere
DS:DX: indica l'indirizzo logico dell'area di memoria (buffer) in cui salvare i bytes della stringa

Il registro coinvolto in uscita è AX . Esso contiene (se CF=0) il numero di bytes effettivamente letti, consentendo una eventuale verifica a posteriori.
Se CF=1 allora in AX  ho il codice d'errore che consente di risalire alla causa del mancato funzionamento.

Questa funzione DOS permette di scrivere una stringa di bytes su un dispositivo di tipo carattere, prelevandola da un buffer.  L'effetto di questa SottoFunzione è sostanzialmente identico a quello della Funzione 40H. I registri in ingresso coinvolti sono:
AH: è posto a 44H
AL: è posto a 03H
BX: indica il numero del gestore (handle) coinvolto:
    0001=handle 1, associato al dispositivo standard d'uscita, video, CON
    0002=handle 2, associato al dispositivo standard d'errore, errore, ERR
    0003=handle 3, associato al dispositivo standard ausiliario, seriale, AUX, COM
    0004=handle 4, associato al dispositivo standard di stampa, stampante, PRN
    0005=handle 5, primo gestore da associare ad un file attualmente aperto
CX: indica il numero di bytes della stringa da scrivere
DS:DX: indica l'indirizzo logico dell'area di memoria (buffer) da cui prelevare i bytes della stringa.

In uscita usa AX dove lascia (se CF=0) il numero di bytes effettivamente scritti, consentendo una eventuale verifica a posteriori:
mentre se CF=1 mette in AX il codice d'errore che consente di risalire alla causa del mancato funzionamento.

SOLUZIONE:

Nella soluzione proposta si è deciso di ricorrere alle CALL per poter riutilizzare lo stesso codice negli esempi successivi

C:\asm>debug
-a 100
180F:0100 ; Carico nel buffer nr byte del
180F:0100 ; file letto
180F:0100 MOV CX,0080
180F:0103 MOV DX,0150
180F:0106 MOV DI,0300
180F:0109 CALL 200
180F:010C ; Stampo il buffer che si
180F:010C ; trova all'indirizzo 0300
180F:010C MOV SI,0300
180F:010F CALL 270
180F:0112 INT 20
180F:0114
-a 150
180F:0150 ; Definisco il nome del
180F:0150 ; file da leggere. Lo 0
180F:0150 ; equivale a \0 finale del C
180F:0150 db 'c:\sechi.txt',0
180F:015D
-a 200
180F:0200 ; Procedura Lettura files - Parametri:
180F:0200 ; DX: indirizzo nome file
180F:0200 ; CX: byte da leggere
180F:0200 ; DI: indirizzo buffer di output
180F:0200 PUSH AX
180F:0201 PUSH BX
180F:0202 PUSH CX
180F:0203 PUSH DX
180F:0204 PUSH DI
180F:0205 ; Apro il file il cui path
180F:0205 ; Þ puntato DX - salvo l'handle
180F:0205 XOR AL,AL
180F:0207 MOV AH,3D
180F:0209 INT 21
180F:020B PUSH AX
180F:020C ; Leggo un nr di byte indicato
180F:020C ; in CX e li scarico nel buffer
180F:020C ; indicato in DX+2
180F:020C ; del file
180F:020C MOV DX, DI
180F:020E ADD DX,2
180F:0211 MOV BX, AX
180F:0213 MOV AH, 3F
180F:0215 INT 21
180F:0217 ; Salvo il numero di byte
180F:0217 ; letti all'indirizzo DI
180F:0217 ; e ripristino l'handle in AX
180F:0217 MOV [DI],AX
180F:0219 POP AX
180F:021A ; Chiudo il file - in BX ho
180F:021A ; l'handle
180F:021A MOV BX,AX
180F:021C MOV AH,3E
180F:021E INT 21
180F:0220 ; Ripristino i registri
180F:0220 POP DI
180F:0221 POP DX
180F:0222 POP CX
180F:0223 POP BX
180F:0224 POP AX
180F:0225 RET
180F:0226
-a 270
180F:0270 ; Analizzo la sequenza e la stampo
180F:0270 ; Salvo i registri
180F:0270 PUSH AX
180F:0271 PUSH CX
180F:0272 PUSH DX
180F:0273 PUSH SI
180F:0274 MOV CX,[SI]
180F:0276 ADD SI,2
180F:0279 ; Stampo il carattere corrente
180F:0279 MOV AH,02
180F:027B MOV DL,[SI]
180F:027D INT 21
180F:027F ; Passo al successivo
180F:027F INC SI
180F:0280 DEC CX
180F:0281 JNZ 279
180F:0283 POP SI
180F:0284 POP DX
180F:0285 POP CX
180F:0286 POP AX
180F:0287 RET
180F:0288
-r cx
CX 0000
:2FF
-n file0.com
-w
Writing 002FF bytes
-q
C:\asm>

Costruire un programma "leggi" che legge i primi 128 byte (80hex) del file c:\sechi.txt e stampa il numero A,I, ... (vocali) presenti.

SOLUZIONE:

Nella soluzione proposta la procedura di lettura del file è identica al precedente esercizio

C:\asm>debug
-a 100
1810:0100 ; Carico nel buffer nr byte del
1810:0100 ; file letto
1810:0100 MOV CX,0080
1810:0103 MOV DX,0150
1810:0106 MOV DI,0300
1810:0109 CALL 200
1810:010C ; LOOP NELL'AREA DI MEMORIA
1810:010C MOV CX, [0300]
1810:0110 MOV SI, 0302
1810:0113 ; Carico il carattere
1810:0113 ; corrente da analizzare
1810:0113 MOV AL,[SI]
1810:0115 ; Aggiorno la stastistica vocali
1810:0115 CALL 400
1810:0118 INC SI
1810:0119 DEC CX
1810:011A JNZ 113
1810:011C ; stampa risultati
1810:011C CALL 500
1810:011F INT 20
1810:0121
-a 130
1810:0130 DB 'A','E','I','U','O'
1810:0135
-a 140
1810:0140 DW 0,0,0,0,0
1810:014A
-a 150
1810:0150 ; Definisco il nome del
1810:0150 ; file da leggere. Lo 0
1810:0150 ; equivale a \0 finale del C
1810:0150 db 'c:\sechi.txt',0
1810:015D
-a 200
1810:0200 ; Procedura Lettura files - Parametri:
1810:0200 ; DX: indirizzo nome file
1810:0200 ; CX: byte da leggere
1810:0200 ; DI: indirizzo buffer di output
1810:0200 PUSH AX
1810:0201 PUSH BX
1810:0202 PUSH CX
1810:0203 PUSH DX
1810:0204 PUSH DI
1810:0205 ; Apro il file il cui path
1810:0205 ; Þ puntato DX - salvo l'handle
1810:0205 XOR AL,AL
1810:0207 MOV AH,3D
1810:0209 INT 21
1810:020B PUSH AX
1810:020C ; Leggo un nr di byte indicato
1810:020C ; in CX e li scarico nel buffer
1810:020C ; indicato in DX+2
1810:020C ; del file
1810:020C MOV DX, DI
1810:020E ADD DX,2
1810:0211 MOV BX, AX
1810:0213 MOV AH, 3F
1810:0215 INT 21
1810:0217 ; Salvo il numero di byte
1810:0217 ; letti all'indirizzo DI
1810:0217 ; e ripristino l'handle in AX
1810:0217 MOV [DI],AX
1810:0219 POP AX
1810:021A ; Chiudo il file - in BX ho
1810:021A ; l'handle
1810:021A MOV BX,AX
1810:021C MOV AH,3E
1810:021E INT 21
1810:0220 ; Ripristino i registri
1810:0220 POP DI
1810:0221 POP DX
1810:0222 POP CX
1810:0223 POP BX
1810:0224 POP AX
1810:0225 RET
1810:0226
-a 270
1810:0270 ; Procedura stampa numero
1810:0270 ; in decimale
1810:0270 ; AX: numero in hex
1810:0270 PUSH AX
1810:0271 PUSH CX
1810:0272 PUSH DX
1810:0273 ; metto 10 nel divisore
1810:0273 ; azzero il contatore
1810:0273 MOV DL,A
1810:0275 XOR CX,CX
1810:0277 ; Divisione per 10 e
1810:0277 ; trasformo il resto in
1810:0277 ; ascii
1810:0277 DIV DL
1810:0279 ADD AH,30
1810:027C PUSH AX
1810:027D INC CX
1810:027E ; Elimino il resto
1810:027E XOR AH,AH
1810:0280 CMP AL,0
1810:0282 JNZ 277
1810:0284 ; Stampo i numeri messi
1810:0284 ; nello stack
1810:0284 POP AX
1810:0285 MOV DL,AH
1810:0287 MOV AH,2
1810:0289 INT 21
1810:028B DEC CX
1810:028C JNZ 0284
1810:028E MOV DL,0a
1810:0290 MOV AH,2
1810:0292 INT 21
1810:0294 MOV DL,0d
1810:0296 MOV AH,2
1810:0298 INT 21
1810:029A POP DX
1810:029B POP CX
1810:029C POP AX
1810:029D RET
1810:029E
-a 400
1810:0400 PUSH AX
1810:0401 PUSH BX
1810:0402 PUSH CX
1810:0403 PUSH DX
1810:0404 PUSH SI
1810:0405 PUSH DI
1810:0406 ; In AL ho la lettera corrente
1810:0406 ; Punto ai simboli delle vocali
1810:0406 MOV SI, 0130
1810:0409 ; e ai contatori delle vocali
1810:0409 MOV DI, 0140
1810:040C ; Inizio LOOP - carico la vocale
1810:040C MOV BL,[SI]
1810:040E CMP AL, BL
1810:0410 JZ 425
1810:0412 ADD BL, 20
1810:0415 CMP AL, BL
1810:0417 JZ 425
1810:0419 ; Passo al contatore della
1810:0419 ; vocale successiva
1810:0419 ADD DI,2
1810:041C INC SI
1810:041D CMP SI,135
1810:0421 JE 42A
1810:0423 JMP 40C
1810:0425 ; Incremento e chiudo la CALL
1810:0425 MOV DX,[DI]
1810:0427 INC DX
1810:0428 MOV [DI],DX
1810:042A ; Ripristino i registri
1810:042A POP DI
1810:042B POP SI
1810:042C POP DX
1810:042D POP CX
1810:042E POP BX
1810:042F POP AX
1810:0430 RET
1810:0431
-a 500
1810:0500 PUSH AX
1810:0501 PUSH BX
1810:0502 PUSH DX
1810:0503 PUSH SI
1810:0504 MOV SI,130
1810:0507 MOV BX,140
1810:050A ; Stampo 'Lettera: '
1810:050A MOV AH,02
1810:050C MOV DL,[SI]
1810:050E INT 21
1810:0510 ; stampo :
1810:0510 MOV DL,3A
1810:0512 INT 21
1810:0514 ; stampo spazio
1810:0514 MOV DL,20
1810:0516 INT 21
1810:0518 ; stampo il numero
1810:0518 MOV AX, [BX]
1810:051A CALL 270
1810:051D ADD BX,2
1810:0520 INC SI
1810:0521 CMP SI,135
1810:0525 JNE 50A
1810:0527 POP SI
1810:0528 POP DX
1810:0529 POP BX
1810:052A POP AX
1810:052B RET
1810:052C
-r cx
CX 0000
:4FF
-n filea.com
-w
Writing 004FF bytes
-q
C:\asm>

Costruire un programma "leggi" che legge l'intero file c:\sechi.txt e lo stampa a video.

SOLUZIONE:

C:\asm>debug
-a 100
1810:0100 ; Apertura File
1810:0100 ; - in AX ho l'handler
1810:0100 MOV DX,0150
1810:0103 CALL 200
1810:0106 PUSH AX
1810:0107 ; Lettura del file
1810:0107 ; - in DI indirizzo del buffer
1810:0107 ; - in [DI] ho il nr di byte
1810:0107 MOV DI,0300
1810:010A CALL 250
1810:010D MOV CX,[DI]
1810:010F CMP CX,0
1810:0112 JZ 11C
1810:0114 ; Stampa buffer
1810:0114 ; - in SI indirizzo del buffer
1810:0114 MOV SI,0300
1810:0117 CALL 270
1810:011A JMP 10A
1810:011C ; Chiusura File
1810:011C ; - in AX ho l'handler
1810:011C POP AX
1810:011D CALL 220
1810:0120 ; Fine programma
1810:0120 INT 20
1810:0122
-a 150
1810:0150 ; Definisco il nome del
1810:0150 ; file da leggere. Lo 0
1810:0150 ; equivale a \0 finale del C
1810:0150 db 'c:\sechi.txt',0
1810:015D
-a 200
1810:0200 ; Procedura Apertura file - Parametri:
1810:0200 ; IN --> DX: indirizzo nome file
1810:0200 ; OUT --> AX: handler del file
1810:0200 XOR AL,AL
1810:0202 MOV AH,3D
1810:0204 INT 21
1810:0206 RET
1810:0207
-a 220
1810:0220 ; Procedura Chiusura file - Parametri:
1810:0220 ; IN --> AX: handler del file
1810:0220 PUSH AX
1810:0221 PUSH BX
1810:0222 MOV BX,AX
1810:0224 MOV AH,3E
1810:0226 INT 21
1810:0228 POP BX
1810:0229 POP AX
1810:022A RET
1810:022B
1810:0250 ; Procedura Lettura file - Parametri:
1810:0250 ; IN --> AX: handler del file
1810:0250 ; IN --> DI: Indirizzo buffer
1810:0250 ; OUT --> [DI]: nr byte letti
1810:0250 PUSH AX
1810:0251 PUSH CX
1810:0252 PUSH BX
1810:0253 PUSH DX
1810:0254 MOV CX,0080
1810:0257 MOV DX,DI
1810:0259 ADD DX,2
1810:025C MOV BX, AX
1810:025E MOV AH, 3F
1810:0260 INT 21
1810:0262 MOV [DI],AX
1810:0264 POP DX
1810:0265 POP CX
1810:0266 POP BX
1810:0267 POP AX
1810:0268 RET
1810:0269
1810:0270 ; Analizzo la sequenza e la stampo
1810:0270 ; Salvo i registri
1810:0270 PUSH AX
1810:0271 PUSH CX
1810:0272 PUSH DX
1810:0273 PUSH SI
1810:0274 MOV CX,[SI]
1810:0276 ADD SI,2
1810:0279 ; Stampo il carattere corrente
1810:0279 MOV AH,02
1810:027B MOV DL,[SI]
1810:027D INT 21
1810:027F ; Passo al successivo
1810:027F INC SI
1810:0280 DEC CX
1810:0281 JNZ 279
1810:0283 POP SI
1810:0284 POP DX
1810:0285 POP CX
1810:0286 POP AX
1810:0287 RET
1810:0288
-r cx
CX 0000
:2FF
-n file0.com
-w
Writing 002FF bytes
-q
C:\asm>