Programmare la REU con il C64

 


di Francesco Sblendorio

(Ringrazio Massimiliano ‘WizKid’ De Ruvo per avermi suggerito delle ottime fonti)

Segue la mia traduzione in italiano dell’articolo REU Programming di Robin Harbron.

Nota: questo articolo è apparso in origine sulla “Loadstar Letter #46” pubblicata nel 1997. Grazie al team di Loadstar per aver dato il permesso di pubblicazione sul mio sito (di Robin Harbron, NdT).

Vuoi sapere come usare la REU nei tuoi programmi? I seguenti programmi BASIC e assembly sono esempi di come verificare la presenza di una REU, determinare le sue dimensioni e quindi memorizzarci, prelevarci o scambiarci segmenti di memoria.

La REU è gestita tramite IO2, cioè le locazioni di memoria che vanno da $DF00 a $DFFF. La REU ha effettivamente 7 registri con alcuni registri che sono replicati, quindi tutte le operazioni di PEEK e POKE saranno effettuate sempre e comunque sulle locazioni di memoria che vanno da $DF00 a $DF0A (in decimale da 57088 a 57098).

Come determinare la presenza di una REU? Se la REU è presente, le locazioni che vanno da $DF02 a $DF05 manterranno i valori che sono in esse memorizzati. Non conosco altre periferiche che si comportano in questo modo, quindi le seguenti routine sfruttano questa proprietà. Nella versione BASIC (che usa solo una variabile per essere il più possibile discreta), X sarà uguale a 0 se non è presente una REU, sarà uguale a 1 se la REU è presente.

10 rem detect
20 forx=2to5:poke57088+x,x:nextx
30 forx=5to2step-1
40 ifpeek(57088+x)<>xthenx=1
50 nextx
60 ifx=0thenprint"no reu"

Nella versione assembly (SYS 16384 per far partire la routine da BASIC), l’accumulatore sarà 0 se non è presente una REU, varrà 1 se invece è presente. In BASIC sarà possibile leggere il contenuto dell’accumulatore attraverso PEEK(780) dopo aver chiamato la routine.

         *= $4000
         ; detect REU

         ldx #2
loop1    txa
         sta $df00,x
         inx
         cpx #6
         bne loop1

         ldx #2
loop2    txa
         cmp $df00,x
         bne noreu
         inx
         cpx #6
         bne loop2

         lda #1
         rts

noreu    lda #0
         rts

Ora, quanto è grande la REU installata? Questa è la mia soluzione (di Robin Harbron, NdT), anche se sembra non essere quella ottimale. Questa routine ci metterà un po’ di secondi nella versione BASIC (ovviamente la versione assembly non impiegherà del tempo significativamente percepibile). In parole povere, la routine scrive il numero di banco nel primo byte di ogni banco (tutti i possibili 256 banchi, il che significherebbe avere una REU da 16MB!). I banchi che non sono disponibili sembreranno “coprire” i banchi esistenti, quindi ciò che sarà scritto in un banco non-disponibile finirà per sovrascrivere ciò che è stato scritto in un precedente banco. Quindi andiamo a scorrere nuovamente i banchi cercando quanti valori crescenti e consecutivi riusciamo a trovare. Questo è il numero di banchi effettivamente disponibili. Questa routine è anche non-distruttiva. Legge e memorizza il contenuto originale della REU, quindi lo riscrive dov’era prima quando ha finito. La routine richiede un buffer di 257 byte per fare questo, a cui puntano la variabile S (nella versione BASIC) o la label temp (nella versione assembly). Dopo aver eseguito la versione BASIC, la variabile A conterrà il numero di banchi disponibili (da 64kB ciascuno, NdT). Per esempio, A=8 dopo l’esecuzione del programma significa avere una REU da 512kB. La versione assembly ritorna il numero di banchi all’interno dell’accumulatore.

10 rem size
15 s=49152
20 poke57090,0:poke57091,192
30 poke57092,0:poke57093,0
40 poke57095,1:poke57096,0
50 poke57098,0
60 forb=0to255:poke57094,b
63 pokes,b:poke57089,178
65 pokes+1+b,peek(s):nextb
70 b=0:o=0
80 poke57094,b:poke57089,177
90 n=peek(s)
100 ifn>otheno=n:b=b+1:goto80
110 a=b
120 forb=255to0step-1:poke57094,b
130 pokes,peek(s+1+b):poke57089,176
140 nextb
150 printa
         *= $4000
temp     = $c000
         ;detect reu size

         lda #0
         sta $df04
         sta $df05
         sta $df08
         sta $df0a
         lda #1
         sta $df07

         lda #temp
         sta $df03

         ldx #0
loop1    stx $df06
         stx temp
         lda #178
         sta $df01
         lda temp
         sta temp+1,x
         inx
         bne loop1

         ldy #177
         ldx #0
         stx old
loop2    stx $df06
         sty $df01
         lda temp
         cmp old
         bcc next
         sta old
         inx
         bne loop2
next     stx size
         ldy #176
         ldx #255
loop3    stx $df06
         lda temp+1,x
         sta temp
         sty $df01
         dex
         cpx #255
         bne loop3
         lda size
         rts
old      .byte 0
size     .byte 0

Veniamo ora allo scopo principale di una REU: memorizzare e restituire dati. La routine seguente è un modello che puoi adattare e usare. Può sia memorizzare sulla REU, sia prelevare dati dalla REU che fare swap tra REU e memoria principale, nel caso particolare si userà il contenuto della memoria video in bassa risoluzione come dati da scambiare.

Ecco una descrizione dettagliata dei registri:

$DF02-$DF03 (57090-57091) puntano all’indirizzo base della memoria del computer con la quale vogliamo operare. È memorizzato nel formato standard LO/HI. $0400 è l’indirizzo che ci andiamo a scrivere per operare con la memoria video.

$DF04-$DF06 (57092-57094) puntano all’indirizzo base della memoria nella REU che vogliamo utilizzare. È memorizzato nel formato LO/HI/BANK. Il numero di banco può essere pensato come a un byte “ulteriormente più alto”. Memorizzeremo le informazioni nella locazione $0 del banco 0.

$DF07-$DF08 (57095-57096) determinano la lunghezza in byte del trasferimento. È memorizzata anch’essa nel formato LO/HI. Memorizzando uno zero in questo registro equivale a specificare la lunghezza massima, cioè 64kB.

$DF0A permette di tenere fisso l’indirizzo della memoria del C64 o della REU, per permetterti di leggere o scrivere particolari locazioni più di una volta. Se il bit 7 è acceso, è fissato l’indirizzo della memoria del C64, se è acceso il bit 6 è fissato l’indirizzo della REU. Ciò ha diversi usi: puoi fissare l’indirizzo della REU (memorizzandoci per esempio 0 o 255) e settore la lunghezza a 8000 byte. Puoi quindi riempire un intero schermo bitmap con quel byte in proprio 8000 cicli o trasferendolo dalla REU al C64! Quest’ultimo modo di procedere è 4 volte più veloce rispetto alla stessa operazione fatta facendo uso della sola CPU. Altro esempio: campionare una particolare locazione di memoria; questo è stato fatto per studiare il generatore di numeri casuali del SID.

$DF01 (57089) esegue l’effettiva operazione. È necessario accendere il bit 7, per dire alla REU di eseguire l’operazione di MOVE. Gli altri bit dicono alla REU come effettuare tale operazione di MOVE:

  • Se il bit 5 è acceso, i registri di indirizzo e di lunghezza rimangono intatti dopo l’esecuzione del comando. Ciò è utile se hai intenzione di eseguire più trasferimenti consecutivi identici. Se il bit è spento, i registri di indirizzo punteranno all’indirizzo immediatamente successivo l’ultimo indirizzo a cui si è acceduto, e il registro di lunghezza sarà impostato a 1.
  • Se il bit 4 è acceso, il comando sarà eseguito immediatamente. Se è spento, il comando non sarà eseguito fin quando non verrà scritta la locazione $FF00. Può apparire strano, ma è utile nel caso si vogliano trasferire dati nelle aree di memoria nei dintorni delle ROM o dell’I/O. Questa opzione dà la possibilità di impostare i registri per il trasferimento, quindi fare switch su I/O (per esempio), quindi eseguire il trasferimento. Per far partire il trasferimento basterà un semplice LDA $FF00 : STA $FF00.
  • I bit 1 e 0 definiscono il tipo di trasferimento. 00 è per trasferire da C64 a REU, 01 per trasferire da REU a C64, 10 per effettuare uno swap tra REU e C64 (in questo caso il tempo impiegato è doppio in quanto doppio è il lavoro da fare), e 11 per effettuare un’operazione di compare tra REU e C64. Per usare la funzione di compare, spegnere il bit 5 di $DF00, eseguire il compare (esattamente come qualsiasi altro trasferimento, con la differenza che nessun byte sarà effettivamente spostato). Ora, se il bit 5 di $DF00 è acceso, allora è stata trovata almeno una differenza tra la memoria della REU e quella del C64.

Segue la versione BASIC. Devi solo impostare la variabile X a seconda del commento presente nella linea 60.

10 poke57090,0:poke57091,4:rem c64
20 poke57092,0:poke57093,0:poke57094,0:rem reu
30 poke57095,232:poke57096,3:rem length
40 poke57098,0:rem not fixed addresses
50 poke57089,128+16+x
60 rem x=0 c64->reu, x=1 reu->c64, x=2 swap c64 and reu

Nella versione assembly, bisogna solo impostare le label c64 all’indirizzo base C64, reu all’indirizzo base REU, bank al numero di banco della REU (ho usato 2 perché il mio assemblatore utilizza per sé i banchi 0 e 1), length al numero di byte da trasferire, e action a 0, 1, 2 o 3 a seconda del tipo di trasferimento che vuoi effettuare.

         *= $4000
         ;reu store/swap/get

c64      = $0400
reu      = $00
bank     = $02
length   = 1000
action   = 0

         lda #c64
         sta $df03
         lda #reu
         sta $df05
         lda #bank
         sta $df06
         lda #length
         sta $df08
         lda #0
         sta $df0a
         lda #144+action
         sta $df01
         rts

Riferimenti esterni:


Commenti

Posta un commento

Post popolari in questo blog

Commodore 16: CPU 7501/8501 FPGA Replacement

Immagine
Un Commodore 16 redivivo dopo la sosituzione della CPU con la sua replica in FPGA di Francesco Sblendorio Uno dei maggiori problemi che affliggono gli utenti dei retro-computer Commodore della serie 264 (C16, Plus/4, C116) è rappresentato dalla fragilità della CPU, il processore MOS 7501/8501. Scalda molto e molto velocemente, ed è uno dei due componenti che si rompono più facilmente, specie dopo un bel trentennio di vita. Implementazione FPGA Fortunatamente la tecnologia FPGA ci viene in aiuto, permettendo di re-implementare teoricamente qualunque chip del passato… pur di trovare qualcuno in grado di farlo! 🙂 Piotr Bugaj  e  Mark Smith  hanno realizzato un  componente sostitutivo della CPU 7501/8501 completamente in FPGA , al momento venduto sul sito  SellMyRetro  al prezzo di  40 sterline inglesi . Eccolo nella sua interezza: Notare in basso a sinistra la freccetta bianca con l’indicazione   “1” : indica il verso corretto di inserimento nello z...
Approfondisci »

MIST how-to: Amiga con Kickstart 1.3 e supporto Hard Disk IDE

Immagine
di  Francesco Sblendorio Prima di passare definitivamente al mondo PC il computer che ho maggiormente utilizzato e sfruttato fino in fondo è stato un modesto Amiga 500 (Kickstart 1.3) con 1MB di RAM e con il solo floppy drive interno. Ci facevo di tutto ma in maniera dannatamente scomoda dato il continuo disk switching, che l’abitudine mi faceva apparire come normale. Desideravo tanto un hard disk ma non l’avevo: l’A590 era una sorta di sogno proibito: perché non replicare oggi, attraverso il   MIST , un Amiga con Kickstart 1.3 e supporto per gli hard disk? Ecco quindi un breve tutorial su come realizzarlo. Versioni Kickstart e supporto IDE Il core  minimig  del  MIST  prevede l’uso degli hard disk sotto forma di file immagine HDF o come partizione della scheda SD. Il controller implementato è però di tipo  IDE  come quello di un A600, mentre le release del Kickstart inferiori alla  2.05  (e quindi la 1.3 ma anche la 2.04 di A5...
Approfondisci »

Zork, CP/M, le adventure Infocom e la personalizzazione del terminale

Immagine
Source:  https://archive.org/serve/ZorkI_r75_earlier_4amCrack di  Francesco Sblendorio Zork è il nome di una delle text adventure più famose della storia, rilasciata da Infocom per la prima volta nel 1977. Non la prima, che fu Colossal Cave Adventure (sempre nel 1977), ma di sicuro un nome che evoca in modo iconico questa categoria di giochi. In comune col capostipite prima citato ha l'essere stata sviluppata in prima battuta per il mainframe PDP-10 . Infocom ha distribuito successivamente decine di altre text adventure (ricordiamo Hitchhiker's guide to the galaxy ) basate sullo stesso modello. A differenza però del capostipite Colossal Cave Adventure che fu scritto in FORTRAN, tutte le text adventure di Infocom sono state in un linguaggio specifico per descrivere il mondo all'interno del quale si muove il giocatore di una adventure: oggi si direbbe un DSL ( D omain S pecific L anguage ). Linguaggio ZIL e Z-Machine multipiattaforma Questo linguaggio fu denominato ...
Approfondisci »

CP/M su Commodore 128: terminali e sequenze di escape

Immagine
di  Francesco Sblendorio Se avete già letto la prima puntata   allora avete già fatto qualche esperimento con il vostro Commodore 128 i n modalità CP/M . Questa volta ci occuperemo della gestione dello schermo e del modo in cui il sistema operativo gestisce l’output verso l’utente. CP/M  nasce negli anni ’70, progettato per funzionare per macchine diverse tra loro ma che condividano la CPU  Intel 8080  (alternativamente il compatibile  Zilog Z80 ). Erano macchine di solito vendute anche  senza  tastiera e monitor ma con connettori seriali attraverso cui era possibile collegare dei  terminali . Da questo punto di vista era simile a  UNIX : l’input/output è uno  stream  sequenziale di caratteri da e verso il terminale. Ciò significa che per avere la possibilità di controllare l’esatta posizione dei messaggi sullo schermo il terminale deve prevedere determinate “sequenze di controllo” (rispetto a cui il sistema operativo è agnost...
Approfondisci »

YAZE: un ottimo emulatore Z80 + CP/M

Immagine
di  Francesco Sblendorio Per chi vuole cimentarsi con l’utilizzo e lo sviluppo su sistemi   CP/M   ci sono essenzialmente due possibilità: usare una macchina reale oppure un emulatore. In questo articolo segnalo un ottimo emulatore di una “generica” macchina equipaggiata di CPU   Z80   nonché del sistema operativo CP/M, che utilizza come input/output la finestra di terminale del nostro sistema operativo preferito (che sia   Linux ,   Windows ,   Mac OS X ). L’emulatore in quesitone si chiama  YAZE , ed è di un certo pregio in quanto, oltre a una perfetta emulazione della CPU  Z80 , consente in maniera relativamente semplice lo scambio di file col sistema host, e viene già fornito di un certo numero di software interessanti, preinstallati e funzionanti, tra cui i compilatori  HiTech C  e  Turbo Modula-2   di  Borland . Download e build YAZE è multipiattaforma, potete scaricarne i sorgenti da questo sito, da c...
Approfondisci »

CP/M su Commodore 128: non solo “DIR”

Immagine
di  Francesco Sblendorio “ […] oltre alla modalità BASIC 7.0 e alla modalità 64, grazie alla presenza del microprocessore Z80, il Commodore 128 può far girare il sistema operativo CP/M, rendendo possibile l’utilizzo di una sterminata libreria di software professionale ” Queste, grossomodo, erano le parole con cui le riviste italiane del 1985 presentavano in pompa magna la possibilità del Commodore 128 di funzionare con il sistema operativo CP/M, per la stragrande maggioranza di utenti Commodore sigla semi-sconosciuta e quasi “mistica”, specie per la possibilità di utilizzare una “ sterminata libreria di software professionale “. Per quelli che, come me, all’epoca erano ragazzini squattrinati ma appassionati di programmazione che dovevano però accontentarsi di un Commodore 64, tale presentazione sembrava promettere un El Dorado informatico. Salvo poi riuscire ad accedere fisicamente al mitico Commodore 128 del compagno di scuola più fortunato, trovare nel mucchio di d...
Approfondisci »

Turbo Pascal porting: dal 7.0 (DOS) al 3.01 (CP/M) – parte 1

Immagine
di  Francesco Sblendorio Lo scopo di questa mini-serie di articoli è riuscire a trasportare programmi scritti anni fa in   Turbo Pascal 7.0   (di cui conserviamo ancora i sorgenti) sotto MS-DOS alla versione   3.01 , disponibile sotto   CP/M , e quindi per ampliare il parco software “retrocomputeristico”. L’idea mi è venuta un giorno in cui ho desiderato veder girare sul mio  Commodore 128  una mia vecchia implementazione del classico gioco delle Torri di Hanoi che scrissi nel 1996 per MS-DOS. Tale implementazione è presente a questo  link . Il risultato è presente su github:  https://github.com/sblendorio/hanoi-cpm . Ha il limite di funzionare bene solo su terminali di tipo  KayPro  e  Commodore 128 , ma i concetti espressi in questa mini-serie di articoli sono generali anche se si farà riferimento ogni tanto in modo specifico alla macchina  Commodore . Partiamo col procurarci una copia di Turbo Pascal 3.01 per CP/M:...
Approfondisci »

Modi di andare a capo

Immagine
The movie "The Shining", directed by Stanley Kubrick, based on the novel by Stephen King. Seen here, Jack Nicholson as Jack Torrance at a typewriter. Initial theatrical release May 23, 1980. Screen capture. © 1980 Warner Bros. Credit: © 1980 Warner Bros. / Flickr / Courtesy Pikturz. Image intended only for use to help promote the film, in an editorial, non-commercial context. di  Francesco Sblendorio Chi utilizza Windows (e chi ha a che fare con chi utilizza   Windows ) lo sa bene: in un file di testo le righe terminano con   due   caratteri:   CR   e   LF   (rispettivamente   ASCII   13   e   10 ). Tutti gli altri sistemi operativi (per esempio   Linux ,   Mac OS X   e qualunque altro   UNIX ) ne utilizzano solo uno,   LF   ( ASCII   10 ), quindi per passare da un sistema all’altro, quando l’editor non lo fa automaticamente, occorre una conversione per passare da un tipo di “ritorno a capo” a...
Approfondisci »

APPENDere in Turbo Pascal per CP/M

Immagine
di  Francesco Sblendorio Prerequisiti tecnici: conoscenza della gestione dei file di testo in Turbo Pascal Consideriamo un programma scritto in  Turbo Pascal 3  che si occupi, in sequenza, di: Aprire un file di testo in scrittura, e scriverci una riga Aprire lo stesso file in  append , quindi scrittura in coda, e aggiungere una seconda riga Aprire lo stesso file in lettura e stamparne il contenuto a video Per esempio… PROGRAM TestAppend; VAR f: TEXT ; s: STRING [80]; BEGIN ASSIGN (f,'test.txt'); REWRITE (f); WRITELN (f,'First row'); CLOSE (f); APPEND (f); WRITELN (f,'Second row'); CLOSE (f); RESET (f); WHILE NOT EOF (f) DO BEGIN READLN (f,s); WRITELN (s) END ; CLOSE (f); END . Se compilato in  Turbo Pascal 3  per  MS-DOS , fila tutto liscio. Se compilato invece in  Turbo Pascal 3  ma sotto  CP/M  in fase di compilazione riceveremo il seguente messaggio di errore: Error 41...
Approfondisci »

Un MIST-ico Amiga

Immagine
di  Francesco Sblendorio Diciamolo pure: noi appassionati di vecchi computer abbiamo un problema ineludibile, che prima o poi si presenterà. Il tempo passa, e le cose si rompono per usura: possiamo sostituire i pezzi guasti, ma si tratta sempre di oggetti che non vengono più prodotti. Una soluzione “soft” è costituita dagli emulatori software: possiamo così conservare “al sicuro” (fino a un certo punto: il tempo passa anche per gli oggetti lasciati a riposo) le nostre preziose vecchie macchine e usare moderni PC che le emulino. Ovviamente però si perde tutto il “feel”, tutto il gusto di lavorare con la vera macchina, essendo quanto mai evidente che trattasi sempre di una “finta”. C’è una possibilità intermedia tra l’uso delle vecchie macchine e qualcosa di più nuovo: l’emulazione hardware. Ciò è reso possibile dalla tecnologia  FPGA  ( Field Programmable Gate Array ): si tratta di circuiti integrati le cui funzionalità sono programmabili via software. In sostanz...
Approfondisci »