Emulatore in Pascal per Commodore 64

Mi sono imbattuto per caso in questo progetto ospitato su GitHub (che rimanda pero' ad un progetto del 2008) in cui viene programmato un semplice emulatore per Commodore 64 e lo ho trovato molto istruttivo perche' il codice (forse perche' in Pascal) e' molto semplice da seguire ed offre uno spaccato della programmazione di una macchina di emulazione

Emulatore in esecuzione in shell su Linux

Si parte semplicemente creando un array di 64K byte che rappresentano la memoria di un C64 (si vedra' in seguito che parte di questi 64Kb saranno occupati da ROM)

Ognuna delle celle dell'array rappresenta una locazione di memoria che puo' essere letta o scritta con un semplice accesso all'array mediante puntatore

Si definiscono quindi le variabili byte A (accumulatore),X,Y,S (stack pointer varia da 0x01FF a 0x0100) ,P (processor status usato per contenere delle flags) ed IR (instruction register, contenuto di memoria che si utilizza) che rappresentano i registri della cpu 6510 con il registro PC (Program counter) che e' di lunghezza word 16 bit (dato che deve contenere un numero 0.65535 )

Il ciclo base dell'emulatore semplicemente legge il contenuto della memoria puntato da PC, interpreta l'istruzione macchine ed modifica il Program Counter per andare alla successiva istruzione

=================================
while true do
begin
    IR := peek(PC);
    inc(PC);
    case IR of
        $00 : interpret instruction $00
        $01 : interpret instruction $01
    else : unknown instruction encountered
end;
end.
=================================

Si devono quindi implementare tutti i codici macchina e come questi modificano lo stato dei registri e le locazioni di memoria ed il flusso di programma

Il 6510 ha circa una ottantina di Opcode da implementare per realizzare un emulatore

Il 6510 usa come base un sistema little endian per cui il byte meno significativo di una word e' registrato nella prima locazione di memoria (o locazione di memoria piu' bassa)

Impostata l'emulazione del processore il passo successivo e' quello di inizializzare le ROM del C64 che, al minimo, devono contenere il Kernal ma puo' essere utile anche avere il Basic. Si prendono i due file del Kernal e del Basic, si legge il contenuto e lo si copia rispettivamente alle locazioni di memoria $A000...$BFFF e $E000...$FFFF. (un altro settore di memoria destinato alla ROM e' compreso tra $D000 e $DFFF....tutto il resto della memoria..anche se frammentato e' considerata RAM)

Il boot della macchina inizia leggendo il valore della locazione $FFFC-$FFFD ed impostando il program counter (una word) a questa locazione (in pratica viene lanciato un Cold Reset della macchina. Di default il valore letto e' $FCE2 (ovvero il mitico SYS 64738)

Il codice ROM si aspetta di dover ricevere informazioni dal VIC e dalla tastiera ma dato che questi non sono ancora emulati al capitolo 3 dell'emulatore viene inviato un segnale 

Nel capitolo 4 viene introdotta la lettura da tastiera e l'output in modalita' testo

Per la tastiera, ogni volta che viene premuto un tasto (if keypressed) viene letta la lunghezza del buffer di tastiera alla locazione $C6 (il buffer di tastiera puo' contenere al massimo 10 caratteri), se il numero e' inferiore a 10 inserisce il nuovo carattere nel buffer che si trova tra $0277 e $0280 ed incrementa la locazione $C6

Per l'output a video viene letta la memoria video testuale che e' compresa tra $400 e $7E7 (1Kb). Nell'emulatore la schermata viene ricreata ogni volta che c'e' un accesso in lettura nell'area di memoria $400-$7E7

Per la posizione del cursore vengono lette le locazioni di memoria $00D3 e $00D6

Dal capitolo 5 viene gestita la creazione degli interrupt. In pratica un interrupt e' un evento che interrompe momentaneamente il ciclo di base del processore While True Do. Gli interrupt possono essere mascherabili e non mascherabili: di fatto viene messo nello stack il valore del program counter  ed il contenuto del registro delle flags (in modo da recuperarlo quando si esce dall'interrupt) e poi si passa il controllo dell'esecuzione al codice dell'interrupt puntato dalle locazioni di memoria $FFFE-$FFFF (essendo un indirizzo di memoria e' una word) se e' mascherabile oppure $FFFA-$FFFB se non e' mascherabile

GLi interrupt sono generati da un dispositivo hardware ma esiste la possibilita' di avere interrupt software via  BRK

Su C64 viene generato un IRQ con un clock di 50 Hz

Il codice Pascal si compila tranquillamente, almeno fino al capitolo 5, su Linux usando  FreePascal

Spectrum ZX128 con emulatore Speecy

https://fms.komkon.org/Speccy/

Shift Sinistro + freccia cursore per scendere e selezionare 48 BASIC. Enter per selezionare

A questo punto si entra nella schermata del Basic...che non dice assolutamente niente
Dal menu Hardware si imposta Input Device come CapsShift+Cursor e si scrive il numero di riga
per esempio 10 ed il cursore si attende un  comando lampeggiando una K..si preme quindi la combinazione CapsShift+P (che corrisponde sull'emulatore a Shift Sinistro+P) e viene mostrato il comando PRINT con il cursore passato ad L lampeggiante perche' si aspetta il parametro del comando PRINT

CTRL+P per scrivere gli apici e poi si scrive la stringa desiderata ed invio. Dal buffer in fondo allo schermo la riga di comando viene spostata nel listato

Per mandare in esecuzione a questo punto  Shift sinistro + R per RUN ed enter per confermare

per correggere qualche errore si osserva che nel listato una riga e' caratterizzata da un segno di maggiore accanto al numero di riga; con le frecce alto e basso si vede che il segno di maggiore di sposta di riga. Una volta individuata la giusta riga si preme EDIT Shift Sinistro + 1 e la riga entra nel buffer di editing in basso

Al contrario del C64 su Spectrum non esiste differenza tra modalita' testo e modalita' grafica. Si possono inserire le primitive grafiche su uno schermo di dimensioni 255x 175

La cosa curiosa e' il motivo per il quale sul C64 si poteva scrivere per esteso i comandi mentre in ZX i comandi erano scritti mediante una combinazione di tasti: ZX in pratica demandava all'utente la tokenizzazione dei comandi, ovvero il primo passo che dal listato conduce all'esecuzione di un programma

Emulatori MAC Old World

Per ricorda un po' i vecchi tempi un po' di giochi con l'emulatore per computer Apple della serie 68000 e PowerPC.
Per motivi legali per poter far funzionare l'emulatore (visto che deve essere utilizzato il file ROM) si deve possedere il calcolatore originale ma vista la mia collezione di Apple che parte dal 512K e finisce ad un MacMini G4 non credo che ci siano problemi

L'emulatore piu' completo da usare e' Basilisk che, su Debian, si installa semplicemente con il comando

apt-get install basilisk2

a questo punto si devono inserire i file ROM (che si scaricano in modo piu' o meno legale da Internet o, avendo l'hardware funzionante, possono essere estratti direttamente). Basilisk gestisce ROM fino ai modelli Quadra

Successivamente si deve avere a disposizione il sistema operativo. Fino a qualche tempo fa Apple metteva a disposizione in download gratuito i System da 6 fino a 7.5.5. (attualmente la pagina non funziona piu' ma qualche anno fa mi ero salvato le immagini dei dischetti)...sempre su Internet si trovano le immagini dei System 8 e 9 ma, essendo tuttora coperti da licenza, si deve aver comprato la licenza per poterli usare

A questo punto si e' pronti. Lanciando il comando BasiliskII (attenzione alla maiuscola iniziale) compare la GUI di configurazione

Per il monitor si puo' scegliere fino a 1024x768 ma i primi monitor di Mac erano 512x342.
Per la memoria e' necessario settare almeno 12 Mb per System 8
Per la Rom si deve settare quella disponibile sotto Memory/Misc
Nei Volumes si deve creare un disco vuoto (diciamo di 20 Mb perche' i primi Mac avevano queso taglio di disco fisso) e l'immagine del System
Pronti per lo Start

Una volta avviato compare prima l'Happy Mac, seguito dalla richiesta di formattazione del disco fisso..si puo' procedere. Terminata questa fase si conclude quindi con l'installazione del System

Terminata l'installazione si puo' fare lo shutdown ed eliminare il Volume dell'immagine del System in modo da effettuare il boot dal disco fisso

Attenzione: non sono riuscito a far partire l'emulatore con il display a colori ma e' un mio difetto dato che il software permette di farlo (la GUI sotto Windows presente questa opzione che non e' presente nella versione nei repository Debian)

Come emulatore esiste anche Mini VMac che pero' non e' disponibile nei repository Debian e che e' indirizzato all'emulazione dei modelli piu' vecchi del tipo 68000 (niente PPC) in particolare di un Mac Plus 4 Mb . Si puo' scaricare direttamente il file eseguibile da questo link.

Per funzionare il programma ha bisogno di una Rom che deve essere denominata come vMac.ROM e che deve risiedere nella stessa directory dell'eseguibile.

Una volta avviato il programma si presenta la schermata con l'Happy Mac e poi l'icona del Floppy con il punto interrogativo. Si deve quindi con il drag&drop trascinare sulla finestra dell'emulatore il file immagine del System e quello del disco fisso vuoto (si trovano delle immagini di vario taglio nel file blank.zip)