content:retrocomputing:vice
Differences
This shows you the differences between two versions of the page.
| Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
| content:retrocomputing:vice [2024/07/12 21:23] – [Mappa della memoria] admin | content:retrocomputing:vice [2026/08/09 20:03] (current) – [Installazione] admin | ||
|---|---|---|---|
| Line 7: | Line 7: | ||
| ===== Installazione ===== | ===== Installazione ===== | ||
| - | Si può installare dai repo Ubuntu, ma poi bisogna copiare le ROM dal pacchetto sorgente, pena errore di //" | + | Si può installare dai repo **Ubuntu**, ma poi bisogna copiare le ROM dal pacchetto sorgente, pena errore di //" |
| Le tre ROM da copiare corrispondono ai chip fisici: | Le tre ROM da copiare corrispondono ai chip fisici: | ||
| Line 31: | Line 31: | ||
| ===== Tastiera ===== | ===== Tastiera ===== | ||
| + | |||
| + | ==== Italiana ==== | ||
| + | |||
| + | Se stampa caratteri //strani//, assicurarsi che sia presente la **tastiera italiana**; andare su // | ||
| + | |||
| + | {{: | ||
| ==== Apple ==== | ==== Apple ==== | ||
| Line 62: | Line 68: | ||
| - | ===== Machine Language Monitor ===== | ||
| - | |||
| - | Un //MLM (machine language monitor)// in assembly è un tool che consente di: | ||
| - | * visualizzare locazioni di memoria | ||
| - | * scrivere/ | ||
| - | * eseguire codice da memoria | ||
| - | |||
| - | Per entrare nel **//VICE Monitor//** digitare **Alt+H** (**Command+H** per i Mac :?:). Quando è attivo il //monitor// non è attivo il Basic. | ||
| - | |||
| - | ==== Visualizzare i registri ==== | ||
| - | |||
| - | Visualizzare i **registri** (con **' | ||
| - | |||
| - | < | ||
| - | (C:$e5d1) R | ||
| - | ADDR A X Y SP 00 01 NV-BDIZC LIN CYC STOPWATCH | ||
| - | .;e5d1 00 00 0a f3 2f 37 00100010 000 000 5425056 | ||
| - | (C: | ||
| - | </ | ||
| - | |||
| - | ==== Leggere e scrivere nella memoria ==== | ||
| - | |||
| - | **Visualizzare** il contenuto della **memoria** (con **' | ||
| - | |||
| - | < | ||
| - | (C:$1011) M 033c 0348 | ||
| - | > | ||
| - | (C: | ||
| - | </ | ||
| - | |||
| - | Le locazioni $033C-$0348 sono tutte vuote; **scriviamo nella memoria** (con **'> | ||
| - | |||
| - | < | ||
| - | (C:$0349) >C:033c ad 80 03 ae 81 03 8d 81 03 8e 80 03 00 | ||
| - | (C:$0349) | ||
| - | </ | ||
| - | |||
| - | <note tip> | ||
| - | |||
| - | Di seguito alcuni **// | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Il programma consiste nello scambiare il contenuto delle locazioni $0380 e $381 (questo è ancora da verificare/ | ||
| - | |||
| - | Per **verificare** il contenuto della memoria appena scritta: | ||
| - | |||
| - | < | ||
| - | (C:$0349) M 033c 0348 | ||
| - | > | ||
| - | (C: | ||
| - | </ | ||
| - | |||
| - | Verifichiamo e quindi copiamo dei valori nelle locazioni $0380 e $381: | ||
| - | |||
| - | < | ||
| - | (C:$0410) M $0380 $0381 | ||
| - | > | ||
| - | |||
| - | (C:$0382) >C:0380 11 99 | ||
| - | |||
| - | (C:$0382) M $0380 $0381 | ||
| - | > | ||
| - | </ | ||
| - | | ||
| - | Adesso la locazione $0380 contiene il valore $11 e la $0381 contiene $99. | ||
| - | |||
| - | ==== Eseguire codice da memoria ==== | ||
| - | |||
| - | **Eseguiamo il programma** (con **' | ||
| - | |||
| - | < | ||
| - | (C:$0382) G 033c | ||
| - | </ | ||
| - | |||
| - | Le due locazioni adesso hanno effettivamente il contenuto invertito: | ||
| - | |||
| - | < | ||
| - | (C:$e5d1) M 0380 0381 | ||
| - | > | ||
| - | </ | ||
| - | |||
| - | ==== Disassemblare ==== | ||
| - | |||
| - | Per **disassemblare** (tradurre da linguaggio macchina in assembly) le locazioni dove si è salvato il codice si fa così (con **' | ||
| - | |||
| - | < | ||
| - | (C:$0382) D 033c 0348 | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | Di seguito uno schema delle operazioni svolte da/verso registri CPU/ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | L' | ||
| - | |||
| - | < | ||
| - | ? PEEK(896) | ||
| - | 153 (cioè $99) | ||
| - | |||
| - | ? PEEK(897) | ||
| - | 17 (cioè $11) | ||
| - | </ | ||
| - | |||
| - | Un altro modo per passare **dal //monitor// al Basic** è premendo **' | ||
| - | |||
| - | ==== Assemblare ==== | ||
| - | |||
| - | Per **assemblare** (scrivere in assembly per poi essere tradotto in linguaggio macchina) si fa così (con **' | ||
| - | |||
| - | < | ||
| - | (C:$034b) A 033c | ||
| - | .033c LDA #$99 | ||
| - | .033e STA $0380 | ||
| - | .0341 LDX #$98 | ||
| - | .0343 STX $0381 | ||
| - | .0346 | ||
| - | (C:$0346) M 033c 034a | ||
| - | > | ||
| - | (C: | ||
| - | </ | ||
| - | |||
| - | Alla locazione 0346 è stato digitato //Return//, per indicare la fine dell' | ||
| - | |||
| - | Il carattere '#' | ||
| - | |||
| - | ==== Basic ==== | ||
| - | |||
| - | L' | ||
| - | |||
| - | < | ||
| - | SYS 828 | ||
| - | </ | ||
| - | |||
| - | Dove ' | ||
| - | |||
| - | Il programma, che carica i valori $99 e $98 nelle locazioni $0380 e $0381, è stato eseguito: | ||
| - | |||
| - | < | ||
| - | (C:$e5d1) M 0380 0381 | ||
| - | > | ||
| - | </ | ||
| - | |||
| - | ==== CHROUT ==== | ||
| - | |||
| - | Per **scrivere a video** possiamo usare il seguente codice: | ||
| - | |||
| - | < | ||
| - | (C:$e5cd) >C:0400 3 9 1 f 20 12 f 2 5 12 14 f | ||
| - | (C:$e5cd) X | ||
| - | </ | ||
| - | |||
| - | dove $0400 è l' | ||
| - | |||
| - | Il codice produrrà il seguente output: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Invece che scrivere direttamente in memoria, si possono usare le **//KERNAL subroutines// | ||
| - | |||
| - | < | ||
| - | (C:$e5cf) A 033c LDA #$41 | ||
| - | .033e JSR $FFD2 | ||
| - | .0341 LDA #$42 | ||
| - | .0343 JSR $FFD2 | ||
| - | .0346 LDA #$43 | ||
| - | .0348 JSR $FFD2 | ||
| - | .034b | ||
| - | (C:$034b) G 033c | ||
| - | </ | ||
| - | |||
| - | A video comparirà velocemente la scritta ' | ||
| - | |||
| - | Aggiungendo ' | ||
| - | |||
| - | < | ||
| - | .034b RTS | ||
| - | </ | ||
| - | |||
| - | è possibile eseguire il comando dal Basic: | ||
| - | |||
| - | < | ||
| - | SYS 828 | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | L' | ||
| - | |||
| - | ==== Loop ==== | ||
| - | |||
| - | Ipotizziamo di voler ottimizzare il precedente codice memorizzando, | ||
| - | |||
| - | < | ||
| - | (C:$e5cd) A 033c | ||
| - | .033c LDX #$00 | ||
| - | .033e LDA $034A,X | ||
| - | .0341 JSR $FFD2 | ||
| - | .0344 INX | ||
| - | .0345 CPX #$06 | ||
| - | .0347 BNE $033E | ||
| - | .0349 RTS | ||
| - | </ | ||
| - | |||
| - | Per questo //loop// andremo ad utilizzare il **registro X** perché: | ||
| - | - il registro X può essere incrementato (riga $0344), a differenza dell' | ||
| - | - può essere implementato, | ||
| - | |||
| - | <note tip>Un indirizzamento di tipo //absolute indexed mode// è limitato a soli 256 byte; per incrementare questo limite si può usare un tipo di indirizzamento // | ||
| - | |||
| - | Le righe $0345 e $0347 possono essere spiegate così: **CPX** (//' | ||
| - | |||
| - | Il **//flag Carry//**, oltre che dalle operazioni aritmetiche, | ||
| - | |||
| - | <note tip> | ||
| - | |||
| - | * **BCS** effettua il //branch// se il valore nel registro (X,Y o A) è >= del valore comparato (flag Carry=1) | ||
| - | * **BCC** effettua il //branch// se il valore nel registro (X,Y o A) è < del valore comparato (flag Carry=0) | ||
| - | |||
| - | Ma in questo caso è quindi necessario cambiare anche la comparazione in **CPX #$07**, con un valore maggiore di uno rispetto a quello cercato. | ||
| - | </ | ||
| - | |||
| - | Riassumendo, | ||
| - | |||
| - | ^Condizione^Flag^Branch da usare^Note^ | ||
| - | |" | ||
| - | |" | ||
| - | |" | ||
| - | |" | ||
| - | |" | ||
| - | |" | ||
| - | |" | ||
| - | |"no overflow numero con segno" (bit 6=0)|**V** - Overflow|BVC (branch overflow clear)|| | ||
| - | |||
| - | Per stampare la stringa voluta, sarà sufficiente memorizzare i valori ASCII esadecimali di HELLO e RETURN a partire dalla locazione $034a. Sono valori che dobbiamo memorizzare come tali, non possiamo // | ||
| - | |||
| - | < | ||
| - | (C:$0368) >C:034a 48 45 4c 4c 4f 0d | ||
| - | </ | ||
| - | |||
| - | Richiamando la subroutine dal Basic otteniamo: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | ==== Salvare ==== | ||
| - | |||
| - | Per potere **salvare il codice** bisogna essere in Basic; bisogna: | ||
| - | * reperire, tramite dei //PEEK//, i valori sia del codice che i valori di testo di HELLO | ||
| - | * ricrearli poi con dei //POKE// | ||
| - | |||
| - | Recuperiamo intanto il codice e valori stringa; il codice in assembly è compreso tra $033c e $034f, che corrispondono ai decimali 828 e 847. Quindi: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Si tratta dei valori // | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Tale codice, che ricrea il codice assembly di prima, si può ovviamente salvare come un qualsiasi programma Basic: | ||
| - | |||
| - | Per **salvare su nastro** usa il comando // | ||
| - | |||
| - | {{: | ||
| - | |||
| - | <note tip> | ||
| - | |||
| - | ==== GETIN e STOP ==== | ||
| - | |||
| - | Un' | ||
| - | |||
| - | C'è anche **STOP** ($FFE1), che testa la pressione di RUN/STOP. | ||
| - | |||
| - | Il seguente programma testa proprio inizialmente la pressione di RUN/STOP ed in tal caso effettua un opportuno RTS: | ||
| - | |||
| - | < | ||
| - | (C:$e5d4) A 033C JSR $FFe1 | ||
| - | .033f BEQ $0351 | ||
| - | |||
| - | ... | ||
| - | |||
| - | .0351 RTS | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Successivamente chiama la KERNAL routine **GETIN** e ottiene quindi la pressione di un tasto, che viene salvato in A sotto forma di codice ASCII: | ||
| - | |||
| - | < | ||
| - | ... | ||
| - | |||
| - | .0341 JSR $FFe4 | ||
| - | .0344 CMP #$30 | ||
| - | .0346 BCC $033C | ||
| - | .0348 CMP #$3A | ||
| - | .034a BCS $033C | ||
| - | .034c JSR $FFD2 | ||
| - | .034f NOP | ||
| - | .0351 RTS | ||
| - | </ | ||
| - | |||
| - | Siccome in questo programma ci interessano solo i **numeri da 0 a 9** (codici ASCII da $30 a $39), le righe $0344-$0346 testano se il codice ASCII digitato è //minore// di 30 (vedi uso **BCC** sopra) mentre le righe $0348-$034a testano se il codice ASCII digitato è //maggiore o uguale// di 3A; non essendo questi valori accettabili, | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Una **tabella completa dei codici ASCII (PETSCII)** per il C64 è presente **[[https:// | ||
| - | |||
| - | Quindi solo la pressione di numeri 0-9 produrrà un output: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | === Esempio 1 === | ||
| - | |||
| - | Questo **altro programma** testa la pressione dei tasti ' | ||
| - | |||
| - | < | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | === Esempio 2 === | ||
| - | |||
| - | Altro esempio, in cui si vuole consentire la visualizzazione dei soli **caratteri alfanumerici** (0-9 e A-Z): | ||
| - | |||
| - | < | ||
| - | (C:$0354) d 033c 0357 | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | Il codice sopra si prende cura di non visualizzare i caratteri prima dello ' | ||
| - | ==== AND, ORA e EOR ==== | ||
| - | |||
| - | Con gli **operandi AND, ORA e EOR** si possono effettuare operazioni sui **singoli bit dell' | ||
| - | |||
| - | * per **azzerare un bit** dell' | ||
| - | < | ||
| - | * per **settare a 1 un bit** dell' | ||
| - | < | ||
| - | * per **invertire alcuni bit** dell' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | ==== Addizione ==== | ||
| - | |||
| - | Per **sommare dei numeri** si usa: | ||
| - | |||
| - | * l' | ||
| - | * l' | ||
| - | * non esiste un operando di addizione //senza// Carry, ma è possibile cancellare il flag Carry, prima dell' | ||
| - | * il **risultato** dell' | ||
| - | |||
| - | L' | ||
| - | |||
| - | <note tip>In realtà, si tratta di due distinte operazioni, che danno come risultato $03C0 e $03C1, che non sono legate tra di loro, se non dal fatto che il //carry// della prima viene riportato con ADC nella seconda</ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | < | ||
| - | (C:$034f) d 033c 034c | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | Qui vengono caricati dei valori nelle locazioni di memoria oggetto di somma: | ||
| - | |||
| - | < | ||
| - | (C:$03a2) >C:03a0 8d 45 | ||
| - | (C:$03a2) >C:03b0 7a 52 | ||
| - | </ | ||
| - | |||
| - | ==== Sottrazione ==== | ||
| - | |||
| - | Prima di effettuare una **sottrazione** conviene settare il **//carry (borrow)// flag con SEC**. | ||
| - | |||
| - | Il seguente esempio sottrae due valori (8D-45) e salva il risultato in $0382: | ||
| - | |||
| - | < | ||
| - | (C:$e5d4) >C:0380 8d 45 ; carica i valori degli operandi in $0380 e $0381 | ||
| - | | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | |||
| - | (C:$04c2) m 0382 0383 | ||
| - | > | ||
| - | </ | ||
| - | |||
| - | ==== Shift register ==== | ||
| - | |||
| - | === ASL === | ||
| - | |||
| - | Per effettuare uno **//shift register// a sinistra**, dell' | ||
| - | |||
| - | * **ASL**: **non** usa il //carry// nel primo bit LSB, che imposta a 0 | ||
| - | * **ROL**: usa il //carry// nel primo bit LSB | ||
| - | |||
| - | Il seguente programma effettua uno **//shift left di A//** e salva il risultato nella locazione $0349; dopo 7 iterazioni un bit si sposta dal bit 0 al bit 7: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | < | ||
| - | (C:$034b) d 033c 0347 | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | |||
| - | (C:$0489) m 0349 034a | ||
| - | > | ||
| - | </ | ||
| - | |||
| - | Ad ogni iterazione, il registro A viene **moltiplicato di 2**. Infatti, la locazione $0349 contiene, dopo 7 iterazioni, il valore $80. | ||
| - | |||
| - | === ROL === | ||
| - | |||
| - | Invece, il seguente programma simula l' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | < | ||
| - | (C:$0348) d 033c 0352 | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | < | ||
| - | |||
| - | ==== Subroutine ==== | ||
| - | |||
| - | Con i comandi **TAX, TXA, TAY, TYA** si copia il contenuto di A in X o Y e viceversa. Qui di seguito un programma che li usa; il **programma effettua la somma di due numeri ad una cifra**. | ||
| - | |||
| - | La **prima parte** riprende quanto evidenziato **[[# | ||
| - | |||
| - | * verifica la pressione di RUN/ | ||
| - | * accetta l' | ||
| - | * stampa il numero | ||
| - | * con l' | ||
| - | |||
| - | < | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | Questa prima parte è una **// | ||
| - | |||
| - | La **seconda parte** richiama due volte la subroutine di input ed effettua e stampa la somma di due numeri nel range 0-9: | ||
| - | |||
| - | < | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | <note important> | ||
| - | |||
| - | Qui di seguito un **esempio** in cui si effettua una **sottrazione di due valori**, sempre usando la // | ||
| - | |||
| - | < | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Qui di seguito un altro **esempio** che testa se un numero è **pari o dispari** facendo un **//LSR//** (logical shift right) e controllando il //carry// (usa la stessa // | ||
| - | |||
| - | < | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | .C: | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | ==== Indirizzamento Indirect, Indexed ==== | ||
| - | |||
| - | L' | ||
| - | ==== Start & End of Basic ==== | ||
| - | |||
| - | Il Start-of-Basic e l' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Da questi valori di default, si capisce che i byte disponibili per Basic, all' | ||
| - | |||
| - | < | ||
| - | |||
| - | ===== Kick Assembler ===== | ||
| - | |||
| - | Un // | ||
| - | |||
| - | Nel classico comando per eseguire un programma da disco: | ||
| - | |||
| - | < | ||
| - | |||
| - | il parametro **' | ||
| - | |||
| - | Se si effettua un //LIST// del programma appena caricato compare solitamente una singola linea: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Che quindi punta alla locazione 2049 ($080b); quella è la locazione da dove parte il programma vero e proprio, quindi abbastanza all' | ||
| - | |||
| - | All' | ||
| - | |||
| - | < | ||
| - | // $801 | ||
| - | BasicUpstart2(main) | ||
| - | |||
| - | // $810 | ||
| - | main: | ||
| - | </ | ||
| - | |||
| - | Quello che fa // | ||
| - | |||
| - | < | ||
| - | 10 SYS2064 | ||
| - | </ | ||
| - | |||
| - | Quindi, nella posizione $801 viene inserito il programma 10 SYS2064, che quindi rimanderà alla locazione 2064 ($810), dove sarà presente il codice //main://. | ||
| - | |||
| - | |||
| - | ===== VIC 20 ===== | ||
| - | |||
| - | ==== VICMON ==== | ||
| - | |||
| - | **VICMON** è un **[[# | ||
| - | |||
| - | * avere il file in **formato .crt** | ||
| - | * impostare la cartuccia come indicato **[[https:// | ||
| - | |||
| - | {{: | ||
| - | |||
| - | ==== Hello World ==== | ||
| - | |||
| - | Di seguito il codice per stampare a video "HELLO WORLD" | ||
| - | |||
| - | < | ||
| - | ., 1100 ldx #$00 | ||
| - | ., 1102 lda $110e,x | ||
| - | ., 1105 beq $110d | ||
| - | ., 1107 jsr $ffd2 | ||
| - | ., 110a inx | ||
| - | ., 110b bne $1102 | ||
| - | ., 110d brk | ||
| - | </ | ||
| - | |||
| - | Questi i valori ASCII da memorizzare: | ||
| - | |||
| - | < | ||
| - | .m 110e | ||
| - | |||
| - | .:110e 48 45 4c 4c 4f | ||
| - | .:1113 20 57 4f 52 4c | ||
| - | .:1118 44 00 | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Conviene prima della ' | ||
| - | |||
| - | < | ||
| - | .m 110e | ||
| - | |||
| - | .:110e 93 48 45 4c 4c | ||
| - | .:1113 4f 20 57 4f 52 | ||
| - | .:1118 4c 44 00 | ||
| - | </ | ||
| - | |||
| - | {{: | ||
| - | |||
| - | === Variante senza CHROUT === | ||
| - | |||
| - | Una variante prevede l' | ||
| - | |||
| - | Come prima cosa conviene sfruttare gli **screen codes** della scritta già presente a video: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Poi basta cambiare l' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Il codice è stato cambiato, ed è stato necessario modificare **sia la mappa schermo che la mappa colore (in rosso)**, altrimenti le scritte non sarebbero comparse; inoltre, a causa dello **// | ||
| - | |||
| - | ==== Mappa della memoria ==== | ||
| - | |||
| - | Programmando il VIC 20 in assembly, si va direttamente ad utilizzare/ | ||
| - | |||
| - | === Reset vector === | ||
| - | |||
| - | L' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | che è l' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | La routine Kernal vera e propria presente in $FD22 è abbastanza complessa; incollo qui di seguito le prime istruzioni: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | === Start-of-Basic RAM === | ||
| - | |||
| - | L' | ||
| - | |||
| - | {{: | ||
| - | |||
| - | tratto da **[[https:// | ||
| - | |||
| - | {{: | ||
| - | |||
| - | <note tip> | ||
| - | Quasi tutta la memoria RAM del VIC 20 è assegnata al BASIC; questo consente di scrivere programmi quanto più grandi possibile. **Per ottenere più spazio per i programmi in linguaggio macchina bisogna quindi riassegnare la memoria assegnata al BASIC** | ||
| - | </ | ||
| - | |||
| - | Questo valore e i successivi, potrebbero interferire con il codice assembly che scriviamo; fino ad adesso per questo abbiamo utilizzato $1100 - 4352: un programma Basic potrebbe andare a sovrascriverlo. E' consigliabile quindi **spostare in avanti il vettore di Start-of-Basic**; | ||
| - | |||
| - | - settare a ' | ||
| - | - impostare i valori della nuova area Basic al valore delle prima locazione + 1 | ||
| - | - dare ' | ||
| - | |||
| - | Per la nuova locazione dello Start-of-Basic prendiamo l' | ||
| - | |||
| - | < | ||
| - | POKE 5120,0 | ||
| - | POKE 43,1:POKE 44,20:NEW | ||
| - | </ | ||
| - | |||
| - | Infatti 5121=1+20*256. | ||
| - | |||
| - | <note tip> | ||
| - | Questo consente di avere uno **spazio sufficiente per l' | ||
| - | </ | ||
| - | |||
| - | Per conferma, si può provare a digitare il seguente programma in BASIC e verificare dove viene memorizzato: | ||
| - | |||
| - | < | ||
| - | 1234PRINT" | ||
| - | </ | ||
| - | |||
| - | e controllare quello che viene memorizzato nel nuovo // | ||
| - | |||
| - | {{: | ||
| - | |||
| - | dove: | ||
| - | |||
| - | * ' | ||
| - | * ' | ||
| - | * ' | ||
| - | * ' | ||
| - | * poi seguono i PETSCII di " | ||
| - | * ' | ||
| - | * la prossima riga inizia, come da indicazioni sopra (//Next link link//), a ' | ||
| - | |||
| - | === Espansione RAM === | ||
| - | |||
| - | Con il VIC 20 è possibile usare una scheda che consente di espandere il computer, così come le originali cartucce da 3K, 8K o 16K. Ad es., una scheda compatibile è la seguente: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | I settaggi DIP switch corrispondono alle linee del connettore di espansione del computer: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Dove: | ||
| - | |||
| - | ^Linea^RAM aggiuntiva^ | ||
| - | |RAM1|1 KB| | ||
| - | |RAM2|1 KB| | ||
| - | |RAM3|1 KB| | ||
| - | |BLK1|8 KB| | ||
| - | |BLK2|8 KB| | ||
| - | |BLK3|8 KB| | ||
| - | |BLK4|8 KB| | ||
| - | |||
| - | Qui uno schema della memoria di un VIC 20: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | {{: | ||
| - | |||
| - | Di seguito è spiegato come settare i DIP switch per ottenere le espansioni RAM: | ||
| - | ^RAM1^RAM2^RAM3^BLK1^BLK2^BLK3^BLK5^Diag^Espansione^Bytes free^ | ||
| - | |1|1|1|0|0|0|0|0| | ||
| - | |1|1|1|1|0|0|0|0| | ||
| - | |1|1|1|1|1|0|0|0| | ||
| - | |1|1|1|1|1|1|0|0| | ||
content/retrocomputing/vice.1720812216.txt.gz · Last modified: by admin
