Sistema di archiviazione ROM (RFS) — Guida tecnica

Guida tecnica RFS

Questa guida documenta l'integrazione hardware del Rom Filing System, l'architettura di memoria, il layout dei moduli software, il design del SD Card Filing System, l'implementazione CP/M e il sistema di build completo. E destinata agli utenti che desiderano comprendere il funzionamento di RFS a livello di sistema, portare RFS su nuovo hardware o eseguire una build completa dai sorgenti.
Per l'uso quotidiano e il riferimento ai comandi del monitor, vedere il Manuale utente. Per le descrizioni dettagliate del codice sorgente in assembler Z80, vedere la Guida per sviluppatori.

Piattaforme hardware

RFS supporta quattro piattaforme hardware. Ciascuna viene selezionata alla compilazione tramite un flag in asm/include/rfs_definitions.asm. Le immagini binarie risultanti differiscono per il layout dei banchi, l'insieme delle funzionalita e gli indirizzi ROM utilizzati.

Scheda RomDisk
Il target RFS originale e piu capace. Il PCB RomDisk si inserisce nello slot di espansione dello Sharp MZ-80A e fornisce:
  • Fino a 4 x 512 KB SST39SF040 Flash RAM — sostituiscono la Monitor ROM e forniscono tre chip User ROM, offrendo fino a 2 MB di storage ROM basato su Flash.
  • 512 KB di RAM statica — disponibile come ulteriore spazio di lavoro paginato (uso futuro).
  • Lettore di schede SDXC con interfaccia SPI hardware (schede v2+) o SPI software a bit-bang (schede v1, tramite la porta parallela della stampante).
  • Un latch codificato (schede v2.0+) che protegge i registri di controllo dei banchi — il latch si apre solo dopo una sequenza fissa di letture agli 8 byte superiori dell'intervallo di indirizzi User ROM (0xEFF8–0xEFFF), impedendo commutazioni accidentali dei banchi durante il funzionamento normale.
Il chip Monitor ROM (a 0x0000–0x0FFF sull'MZ-80A) viene sostituito da uno zoccolo Flash RAM paginato adattato per apparire come una finestra di 4 KB sull'intero chip da 512 KB. Analogamente la User ROM (a 0xE800–0xEFFF) viene sostituita da una finestra paginata di 2 KB.

Interfaccia floppy SFD-700
La scheda di interfaccia floppy disk SFD-700 mkII include una Flash ROM da 512 KB. RFS occupa pagine di questa Flash ROM accanto al codice di avvio floppy AFI:
  • 0x00000–0x00FFF — ROM di avvio floppy AFI MZ-80A (originale, necessaria per il trucco DRQ a 2 MHz).
  • 0x01000–0x01FFF — ROM di avvio floppy AFI MZ-700.
  • 0x02000–0x0BFFF — Firmware RFS (10 x 2 KB banchi User ROM, equivalenti ai banchi User ROM 0–4).
  • 0x0C000 in poi — File system ROM (programmi memorizzati come immagini MZF).
Nella build SFD-700 il codice della User ROM viene assemblato per iniziare a 0xE000 e allinearsi a 0xE300 (rispettando l'intervallo I/O mappato in memoria dell'MZ-700). Non e presente alcuna scheda SD; i comandi della scheda SD sono esclusi da questa build.

picoZ80
La scheda picoZ80 (sostituzione Z80 basata su RP2350) emula la mappa di memoria completa dell'MZ-80A in PSRAM e Flash. RFS viene eseguito all'interno dello spazio ROM emulato, utilizzando gli stessi indirizzi di banco della build RomDisk. La picoZ80 fornisce il proprio storage su scheda SD connesso via SPI, quindi l'intero insieme di funzionalita RomDisk (unita su scheda SD, copia nastro↔SD, ecc.) e disponibile.

RFS viene eseguito sotto qualsiasi persona macchina che la picoZ80 presenta all'host. Oltre all'MZ-80A, questa ora include la persona Sharp MZ-80K, che puo' collegare le stesse schede di interfaccia Sharp dell'MZ-80A (RFS, MZ80AFI, MZ-1E14/E19, MZ-1R12/R18/R37, PIO-3034) oltre al proprio controller floppy nativo MZ-80FD (T3444M). Con una scheda MZ80AFI, il CBIOS CP/M di RFS rileva automaticamente i dischi CP/M originali dell'MZ-80K (settori da 128 byte, non invertiti) e li monta come unita' CP/M C:/D:.

Architettura di memoria

La CPU Z80 dello Sharp MZ-80A indirizza 64 KB di memoria. RFS colloca l'intero firmware nelle due finestre ROM senza consumare RAM, lasciando l'intero intervallo 0x1200–0xCFFF per i programmi utente.

Layout dello spazio di indirizzamento Z80 
Address     Size    Contents
─────────────────────────────────────────────────────────────────────
0x0000      4 KB    Monitor ROM (MROM)  — 4 KB window into 512 KB Flash
                    Paged across 16 banks:
                      banks 0–5 = monitor variants + CP/M CBIOS + RFS mrom utils,
                      banks 6–7 = ASM/DASM opcode tables,
                      bank 8 = IPL, bank 9 = RFS message strings,
                      banks 10–15 = reserved
0x1000      256 B   MZ-80A system variables / stack
0x1200    ~46 KB    User RAM  (main program area)
0xCFFF
0xD000      12 KB   Video RAM + memory-mapped I/O (MZ-80A hardware)
0xE800       2 KB   User ROM (UROM) — 2 KB window into 512 KB Flash
                    Paged: banks 0–11 = RFS modules,
                           banks 12–15 = CP/M CBIOS banks
                    Note: on the SFD-700 build the UROM window starts at
                    0xE300 (0xE000–0xE2FF is MZ-700 memory-mapped I/O).
                    The command table (CMDTABLE2) is placed at 0xE300 and
                    the main bank code remains at 0xE800 as on other builds.
0xEFFF
0xF000       4 KB   Floppy AFI ROM / FDC ROM (SFD-700 MROM location)
─────────────────────────────────────────────────────────────────────

Banchi Monitor ROM (4 KB ciascuno)
La finestra Monitor ROM a 0x0000–0x0FFF viene commutata tra 16 pagine memorizzate nel chip Flash della Monitor ROM. Di queste, tre pagine (banchi 6, 7 e 9) sono dedicate a RFS — contengono rispettivamente le tabelle di opcode dell'assemblatore/disassemblatore Z80 e le stringhe di messaggi:
Banco Modulo Descrizione
0 monitor_sa1510.asm ROM monitor SA-1510 originale — 40 colonne. Il banco predefinito all’accensione.
1 monitor_80c_sa1510.asm SA-1510 adattato per display a 80 colonne (richiede l’upgrade Kuma).
2 cbios.asm Kernel CBIOS CP/M 2.2 — qui rilocato durante l’avvio CP/M.
3 rfs_mrom.asm Utilita’ Monitor ROM di RFS. Viene eseguito dallo spazio MROM per scansionare e caricare i file MZF memorizzati nella Flash User ROM, poiche’ il codice User ROM non puo’ paginare se stesso fuori.
4 monitor_1z-013a.asm Monitor MZ-1Z-013A (variante MZ-700 / MZ-1200).
5 monitor_80c_1z-013a.asm Monitor 1Z-013A adattato per display a 80 colonne.
6 rfs_mrom_bank6.asm Tabella opcode 1 assemblatore/disassemblatore Z80.
7 rfs_mrom_bank7.asm Tabella opcode 2 assemblatore/disassemblatore Z80.
8 ipl.asm Initial Program Loader.
9 rfs_mrom_bank9.asm Repository delle stringhe di messaggi RFS.
10–15 — Riservato / libero.

Banchi User ROM (2 KB ciascuno)
La finestra User ROM a 0xE800–0xEFFF viene commutata tra 16 banchi nei chip Flash della User ROM — 12 banchi per RFS (banchi 0–11) e 4 banchi per il CBIOS CP/M (banchi 12–15):
Banco Modulo Descrizione
0 rfs.asm Punto di ingresso principale RFS, dispatcher dei comandi, tabella dei comandi, infrastruttura di commutazione banchi condivisa da tutti i banchi.
1 rfs_bank1.asm Funzioni del controller floppy disk (FDC) — avvio floppy (FL), directory floppy (FD), copia floppy (FC), floppy-a-nastro (FD2T), nastro-a-floppy (T2FD) e selezione unita’. L’intero set di comandi FDC viene assemblato in tutte le build.
2 rfs_bank2.asm Controller scheda SD — driver SPI, inizializzazione scheda SD, directory SDCFS e lettura/scrittura file. Non assemblato nella build SFD-700 (nessun hardware scheda SD).
3 rfs_bank3.asm Utilita’ di memoria del monitor — dump esadecimale (D), modifica memoria (M), copia memoria (CP), dump file scheda SD (DUC), lettura/scrittura porte I/O (IN / OUT). La copia nastro↔SD (T2SD/SD2T) e inclusa solo nelle build RomDisk / picoZ80.
4 rfs_bank4.asm Controller CMT (cassetta) — caricamento, salvataggio e verifica nastro.
5 rfs_bank5.asm Funzioni di utilita’ generale — stampa formattata, routine per stringhe, codice helper condiviso.
6 rfs_bank6.asm Tabella opcode 1 assemblatore/disassemblatore Z80, funzione PRINTMSG e infrastruttura delle stringhe di messaggi.
7 rfs_bank7.asm Tabella opcode 2 assemblatore/disassemblatore Z80, disassemblatore Z80 (DASM), test memoria DRAM, test timer 8253.
8 rfs_bank8.asm Assemblatore Z80 interattivo (ASM).
9 rfs_bank9.asm Directory ROM, ricerca file, funzioni di caricamento e stampa (spostate dal banco 0 per liberare spazio).
10 rfs_bank10.asm Riservato / libero.
11 rfs_bank11.asm Schermata di aiuto.
12 cbios_bank1.asm CBIOS CP/M — funzioni audio, RTC, tastiera e utilita’ di basso livello.
13 cbios_bank2.asm CBIOS CP/M — driver schermo ed emulazione terminale ANSI.
14 cbios_bank3.asm CBIOS CP/M — driver scheda SD (fornisce le unita’ CP/M A:–G:).
15 cbios_bank4.asm CBIOS CP/M — controller floppy disk. Rileva automaticamente la dimensione del settore tramite la scheda MZ80AFI (dischi MZ-80A da 256 byte vs dischi MZ-80K da 128 byte) e puo’ leggere direttamente i dischi CP/M originali dell’MZ-80K, mappandoli sulle unita’ CP/M C:/D:.

Meccanismo di commutazione banchi
Poiche' lo Z80 puo' vedere solo una fetta di 2 KB della User ROM in un dato momento, ogni banco contiene una copia dello stub di commutazione banchi — un piccolo blocco fisso di codice a un indirizzo noto all'interno della finestra di 2 KB. Quando il banco 0 deve chiamare una routine nel banco 3:
  1. Scrive il numero del banco di destinazione nel registro di latch hardware dei banchi.
  2. Salta al punto di ingresso ben noto nel banco appena mappato.
  3. Esegue la routine richiesta.
  4. Riscrive il banco 0 nel latch e ritorna.
Questo meccanismo fa si' che tutti i 12 banchi RFS (12 x 2 KB = 24 KB) piu i 4 banchi CBIOS (4 x 2 KB = 8 KB) — 32 KB in totale — siano accessibili da qualsiasi contesto di esecuzione, anche se solo 2 KB sono visibili alla volta. Lo stub di commutazione banchi occupa i primi 32 byte di ciascun banco (0xE800–0xE81F), e la tabella di commutazione banchi inizia a 0xE800 + 0xB0. In modo critico: nessuna istruzione di loop deve mai estendersi sull'intervallo 0xEFF8–0xEFFF sulle schede RomDisk v2+, poiche' quegli indirizzi attivano la sequenza di sblocco del latch codificato.

Architettura software

La tabella completa dei moduli — ogni file sorgente, la sua ROM di destinazione, il banco e la funzione:
Modulo ROM Banco Dimensione Descrizione
rfs.asm User 0 2 KB Dispatcher dei comandi, tabella dei comandi, infrastruttura di commutazione banchi.
rfs_bank1.asm User 1 2 KB Controller floppy disk — selezione unita’, avvio FDC, copia floppy (FC), floppy-a-nastro (FD2T), nastro-a-floppy (T2FD) (RomDisk/picoZ80); solo salto FDCK AFI (SFD-700).
rfs_bank2.asm User 2 2 KB Controller scheda SD — SPI, directory SDCFS, lettura/scrittura file. Non assemblato nella build SFD-700.
rfs_bank3.asm User 3 2 KB Utilita’ di memoria — D, M, CP, DUC, IN, OUT (tutte le build); T2SD, SD2T (solo RomDisk / picoZ80).
rfs_bank4.asm User 4 2 KB Controller CMT — caricamento, salvataggio, verifica nastro.
rfs_bank5.asm User 5 2 KB Utilita’ generali — routine di stampa, helper per stringhe.
rfs_bank6.asm User 6 2 KB Tabella opcode 1 assemblatore/disassemblatore Z80, funzione PRINTMSG, infrastruttura stringhe di messaggi.
rfs_bank7.asm User 7 2 KB Tabella opcode 2 assemblatore/disassemblatore Z80, DASM, test DRAM, test timer.
rfs_bank8.asm User 8 2 KB Assemblatore Z80 interattivo (ASM).
rfs_bank9.asm User 9 2 KB Directory ROM, ricerca file, funzioni di caricamento e stampa (spostate dal banco 0).
rfs_bank10.asm User 10 2 KB Riservato / libero.
rfs_bank11.asm User 11 2 KB Schermata di aiuto.
cbios_bank1.asm User 12 2 KB CBIOS CP/M — audio, RTC, tastiera, utilita’ di basso livello.
cbios_bank2.asm User 13 2 KB CBIOS CP/M — driver schermo, emulatore terminale ANSI.
cbios_bank3.asm User 14 2 KB CBIOS CP/M — driver scheda SD (unita’ CP/M A:–G:).
cbios_bank4.asm User 15 2 KB CBIOS CP/M — controller floppy disk.
monitor_sa1510.asm Monitor 0 4 KB ROM monitor SA-1510 originale (40 colonne).
monitor_80c_sa1510.asm Monitor 1 4 KB SA-1510 adattato per display a 80 colonne.
cbios.asm Monitor 2 4 KB Kernel CBIOS CP/M 2.2 (rilocato a 0xC000 durante l’avvio CP/M).
rfs_mrom.asm Monitor 3 4 KB Utilita’ Monitor ROM di RFS — scansione ROM, caricamento MZF.
monitor_1z-013a.asm Monitor 4 4 KB Monitor MZ-1Z-013A (variante MZ-700 / MZ-1200).
monitor_80c_1z-013a.asm Monitor 5 4 KB 1Z-013A adattato per display a 80 colonne.
rfs_mrom_bank6.asm Monitor 6 4 KB Tabella opcode 1 assemblatore/disassemblatore Z80.
rfs_mrom_bank7.asm Monitor 7 4 KB Tabella opcode 2 assemblatore/disassemblatore Z80.
ipl.asm Monitor 8 4 KB Initial Program Loader.
rfs_mrom_bank9.asm Monitor 9 4 KB Repository delle stringhe di messaggi RFS.
CP/M 2.2 offre 47 KB di RAM programma utilizzabile. CCP e BDOS risiedono in RAM e possono essere sovrascritti da applicazioni di grandi dimensioni (vengono ricaricati al warm boot). Il CBIOS risiede interamente nel banco 2 della Monitor ROM e nei banchi 12–15 della User ROM, senza consumare RAM programma.
La Monitor ROM produce inoltre, in fase di build, diverse immagini varianti aggiuntive: le varianti hi-load di SA-1510 e 80c SA-1510 (usate quando la DRAM deve estendersi su 0x0000–0xCFFF), e le varianti Kuma-80 (selezionate tramite il flag KUMA80_ENA).

SD Card Filing System (SDCFS)

Anziche' implementare FAT (che sarebbe troppo grande per i banchi ROM da 2 KB disponibili), RFS utilizza un file system appositamente progettato chiamato SD Card Filing System (SDCFS). Il design privilegia la semplicita' e un'occupazione ROM ridotta rispetto alla flessibilita'.

Struttura della directory
Ogni immagine di unita' SDCFS contiene una directory piatta di massimo 256 voci. Ogni voce e esattamente di 32 byte, basata sul formato standard dell'intestazione del nastro MZF:
Campo Byte Descrizione
FLAG1 1 Bit 7 = 1: voce valida. Bit 7 = 0: inattiva / eliminata.
FLAG2 1 Tipo di esecuzione MZF (0x01 = programma binario).
FILE NAME 17 Nome file MZF standard di 17 caratteri (codifica caratteri Sharp).
START SECTOR 4 Primo settore all’interno di questa immagine di unita’ in cui inizia il blocco dati del file.
SIZE 2 Conteggio byte effettivo dei dati del file.
LOAD ADDR 2 Indirizzo RAM Z80 dove caricare i dati del file.
EXEC ADDR 2 Indirizzo di esecuzione automatica per file binari (salto dopo il caricamento).
RESERVED 3 Non utilizzato attualmente.
La directory occupa i primi 8 KB di ogni immagine di unita' (256 voci x 32 byte). I dati dei file seguono immediatamente, a partire dal 256-esimo limite di 32 byte. A ogni file viene allocato un blocco fisso di 64 KB — corrispondente alla dimensione massima del blocco di nastro CMT — il che mantiene il layout banalmente semplice e rende la copia SD↔nastro un trasferimento diretto byte per byte.

Layout della scheda SD 
ADDRESS    CONTENT
────────────────────────────────────────────────────────────
0x00000000  RFS DRIVE 0
              0x00000000–0x00001FE0  Directory (256 × 32 B)
              0x00002000–0xFF2000    File blocks (256 × 64 KB)
0x01002000  RFS DRIVE 1  (same structure)
...
0x09012000  RFS DRIVE 9  (same structure)
0x0A014000  (padding to 256 MB boundary)
────────────────────────────────────────────────────────────
0x10000000  CP/M DISK IMAGE 0   (16 MB — 32 sectors × 1024 tracks)
0x11000000  CP/M DISK IMAGE 1
...
0xXX000000  CP/M DISK IMAGE 6
────────────────────────────────────────────────────────────
Non viene scritta alcuna tabella delle partizioni. L'immagine SDCFS inizia al byte 0 della scheda SD. Le immagini disco CP/M iniziano al limite di 256 MB per lasciare spazio a tutte le 10 unita' RFS indipendentemente da quanto siano piene.

Implementazione CP/M 2.2

Processo di avvio
L'avvio CP/M su RFS avviene in due fasi:
  1. Fase 1 — avvio AFI: Il codice ROM AFI (Auto Floppy Interface) MZ-80A originale a 0xF000 legge il primo settore del floppy o il blocco di avvio della scheda SD. Verifica la presenza dei byte marcatori 0x02 + "IPLPRO" al byte 0 (la firma dei dischi avviabili CP/M dell'MZ-80A). Se trovata, passa il controllo al loader di secondo stadio incapsulato in quel settore.
  2. Fase 2 — caricamento CCP+BDOS+CBIOS: Il loader di secondo stadio legge CCP, BDOS e CBIOS dal disco nella RAM a partire da 0x9C00. Una volta caricati, viene chiamato il punto di ingresso cold-boot del CBIOS. Il CBIOS configura l'hardware (tastiera, schermo, unita' disco) e passa il controllo al CCP a 0x9C00.

Architettura del CBIOS
Il Custom BIOS (CBIOS) e suddiviso in cinque moduli ROM per rientrare nello spazio di banco disponibile:
Modulo Posizione ROM Contenuto
cbios.asm MROM banco 2 (0xC000–0xCFFF) Punti di ingresso CBIOS (tutti i 17 vettori API), cold/warm boot, gestore interrupt, controller del disco ROM, tabelle dei parametri del disco.
cbios_bank1.asm UROM banco 12 Audio (campanello, melodia), routine dell’orologio in tempo reale, gestore tastiera con auto-ripetizione.
cbios_bank2.asm UROM banco 13 Driver schermo (output caratteri, scroll, cursore), emulatore terminale ANSI (sottoinsieme VT52/VT100).
cbios_bank3.asm UROM banco 14 Driver disco scheda SD — legge e scrive settori CP/M da 128 byte dalle immagini di unita’ SDCFS a partire dal limite di 256 MB.
cbios_bank4.asm UROM banco 15 Controller floppy disk — supporto standard per unita’ da 8 pollici/5,25 pollici per dischi CP/M fisici.

API del CBIOS
Il CBIOS CP/M implementa tutti i 17 punti di ingresso API standard di CP/M 2.2:
Punto di ingresso Descrizione
BOOT Avvio a freddo — inizializza tutto l’hardware, imposta le tabelle dei parametri del disco, chiama il CCP.
WBOOT Avvio a caldo — ripristina lo stato dell’hardware, ricarica CCP+BDOS dal disco, chiama il CCP.
CONST Stato console — restituisce 0xFF se un tasto e in attesa, 0x00 altrimenti.
CONIN Input console — attende la pressione di un tasto e restituisce il codice ASCII.
CONOUT Output console — scrive un carattere sullo schermo.
LIST Output stampante — invia un carattere alla stampante collegata.
PUNCH Output perforatore/nastro — invia al dispositivo perforatore di nastro.
READER Input lettore — legge dal dispositivo lettore di nastro.
HOME Posiziona la testina sulla traccia 0 del disco attualmente selezionato.
SELDSK Seleziona un’unita’ disco (A:–G:) e restituisce l’indirizzo del Disk Parameter Header.
SETTRK Imposta la traccia del disco per la successiva operazione di lettura o scrittura.
SETSEC Imposta il settore del disco per la successiva operazione di lettura o scrittura.
SETDMA Imposta il Disk Memory Address — dove i dati verranno letti o scritti.
READ Legge un settore da 128 byte dal disco selezionato nel buffer DMA.
WRITE Scrive un settore da 128 byte dal buffer DMA al disco selezionato.
LISTST Stato stampante — restituisce lo stato di pronto del dispositivo di stampa.
SECTRN Traduzione settore — mappa i numeri di settore logici sulle posizioni fisiche usando la skew table del disco.

Configurazione delle unita' CP/M
Le unita' CP/M vengono create dinamicamente durante il cold boot dal CBIOS, a seconda dei controller disco disponibili. La mappatura standard delle unita' su un sistema RomDisk / picoZ80 completamente equipaggiato e:
Unita’ CP/M Controller Immagine
A: Scheda SD CPM_SYSTEM — programmi OS, Turbo Pascal, Hi-Soft C, Fortran 80, MS-BASIC 80
B: Scheda SD Pascal MTP v5.61, Turbo Pascal v3.00a, dischi Pascal User Group
C: Scheda SD PLI, PLM 80, WordStar v3.0/v3.3/v4.0
D:–G: Scheda SD Dischi della collezione CP/M di Grant Searle C0–F9

Sistema di build

RFS si compila su Linux (Debian/Ubuntu), macOS e Windows (tramite WSL2). Il sistema di build e quasi interamente autonomo all'interno del repository. Il modo consigliato per compilare e lo script di setup automatizzato per la propria piattaforma (vedere Setup e build automatizzati di seguito); i flag e i passaggi manuali che seguono sono per utenti avanzati e ricostruzioni parziali.

Prerequisiti
Strumento Scopo
Java JRE 8+ Esegue l’assemblatore Z80 GLASS (tools/glass.jar). java deve essere nel PATH.
bash Tutti gli script di build sono script shell bash.
perl Richiesto da tools/mzftool.pl per la manipolazione dei file MZF.
gcc / make Compila cpmtools dai sorgenti alla prima build (automatico).
dd, cat, stat Utilita’ Linux standard usate dagli script di packaging.
L'assemblatore Z80 GLASS e incluso in tools/glass.jar — non e richiesta alcuna installazione separata.

Setup e build automatizzati (consigliato)
Lo script di setup automatizzato per la propria piattaforma installa i prerequisiti, clona il repository (se non vi trovate gia all'interno di un checkout), scarica le immagini dei contenuti, scrive il file di ambiente e propone di eseguire la prima build — il tutto in modo interattivo, con valori predefiniti ragionevoli che potete accettare premendo Invio. Ogni script e autonomo: copiate il singolo file relativo alla vostra piattaforma ed eseguitelo.

macOS / Linux / WSL — setup_RFS.sh

chmod +x setup_RFS.sh
./setup_RFS.sh

Windows 10 / 11 — setup_RFS_windows_native.ps1 (consigliato — nativo, senza WSL). Da una PowerShell:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\setup_RFS_windows_native.ps1

Lo script nativo usa winget per installare Git for Windows (bash, coreutils, perl, curl) e una Temurin JRE (per l’assemblatore GLASS), clona il repo, scarica il bundle dei contenuti ed esegue ./build.sh tramite Git Bash — senza WSL, Docker o riavvio. Due strumenti host precompilati (tools/cpmcp.exe, tools/sdtool.exe) sono inclusi, quindi non serve un compilatore C su Windows.

Windows 10 / 11 — setup_RFS_windows.ps1 (alternativa — WSL2 / Ubuntu). Da una PowerShell con privilegi di Amministratore:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\setup_RFS_windows.ps1

Questa variante WSL installa WSL2 + Ubuntu se non sono gia presenti (riavvio una tantum richiesto — riavviate, avviate Ubuntu una volta per creare il vostro utente Linux, quindi rieseguite), poi esegue setup_RFS.sh all’interno di Ubuntu. Preferite lo script nativo a meno che non desideriate specificamente un ambiente WSL.

Domande poste dal setup, e cosa fare. Ogni richiesta ha un valore predefinito sicuro tra parentesi — la lettera maiuscola e il valore predefinito, quindi premendo Invio lo si accetta.

Solo Windows (PowerShell, prima dell’esecuzione del setup Linux):

Richiesta Predefinito Cosa fare
Continue anyway? [y/N] (se non avviato come Amministratore) No N, quindi riaprire PowerShell come Amministratore — l’installazione di WSL richiede i privilegi di amministratore.
Install WSL2 + Ubuntu now? [y/N] (se WSL/Ubuntu manca) No y — Windows installa WSL2 + Ubuntu, quindi chiede di riavviare; in seguito avviare Ubuntu una volta per creare il vostro utente e rieseguire.
Repo URL [https://git.eaw.app/eaw/RFS.git] repo pubblico Invio per il repo pubblico, oppure incollare un URL diverso (ad es. il repo di sviluppo privato).

macOS / Linux / WSL (shell Linux/Ubuntu):

Richiesta Predefinito Cosa fare
Install now? [Y/n] (se mancano strumenti) Si Invio — installa gli strumenti mancanti tramite apt/dnf/pacman o Homebrew (macOS); potrebbe richiedere sudo. Su macOS attiva anche gli Xcode CLT e richiede Homebrew.
Repo URL [https://git.eaw.app/eaw/RFS.git]: (se non gia in un checkout) repo pubblico Invio per il pubblico, oppure incollare l’URL del repo privato. (Saltata su Windows — gia scelto.)
Install directory [~/RFS]: (in fase di clonazione) ~/RFS Invio per ~/RFS, oppure digitare un percorso.
Remove <dir> and re-clone …? [y/N] (se quella dir contiene un repo diverso) No y solo se sicuri; altrimenti N e scegliere un’altra directory.
Download and install them now? [Y/n] (contenuti ~110 MB) Si Invio per scaricare i contenuti MZF/disco/CP/M/BASIC (necessari per una build completa); n solo se un checkout SharpSoft adiacente li fornisce gia.
Run the first build now (./build.sh -m …)? [Y/n] Si Invio per compilare subito (verifica l’ambiente). La prima build usa -m per elaborare MZF → MZB/.

Potrebbe inoltre esservi richiesta la password sudo e le vostre credenziali git (repo privato).

Dopo il setup, ricompilate con ./build.sh -m (prima build) poi ./build.sh; su macOS eseguite prima source ./rfs_env.sh. build.sh compila tutte le varianti per impostazione predefinita; passate un nome di variante (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k) per compilarne una sola — la selezione di una variante configura automaticamente i flag di build. Opzioni: -m (elabora MZF), -s (salta l'assemblaggio condiviso), -c (clean), -v (verbose), -h (help).

Avanzato: flag di build (manuale)
Per la maggior parte delle build non serve questa sezione — build.sh <variant> imposta questi flag automaticamente. Per configurare un target a mano, modifica asm/include/rfs_definitions.asm e imposta esattamente un flag di target a 1 (tutti gli altri devono essere 0):
Flag Target
BUILD_ROMDISK EQU 1 Scheda RomDisk
BUILD_SFD700 EQU 1 Interfaccia floppy SFD-700
BUILD_PICOZ80 EQU 1 Scheda picoZ80
Flag di funzionalita' opzionali aggiuntivi:
Flag Default Descrizione
KUMA80_ENA 0 Impostare a 1 se e installato l’upgrade Kuma 40/80 colonne.
VIDEOMODULE_ENA 0 Impostare a 1 se e installato il Video Module a colori 40/80.
FUSIONX_ENA 0 Impostare a 1 quando si esegue sulla scheda tranZPUter FusionX.
HW_SPI_ENA 1 SPI hardware (PCB RomDisk v2+). Lasciare a 1 per tutte le schede attuali.
SW_SPI_ENA 0 SPI software a bit-bang (RomDisk v1 tramite porta parallela).
ENADEBUG 0 Abilita l’output di debug in fase di assemblaggio.

Passaggi di build manuali e cosa fa build.sh
Se preferite non usare lo script di setup (o state automatizzando una build CI), clonate e compilate direttamente. Dovete gia avere i prerequisiti installati e, su un clone standalone appena creato, scaricare voi stessi le immagini dei contenuti (oppure eseguire setup_RFS.sh, che lo fa per voi). 
git clone --recurse-submodules https://git.eaw.app/eaw/RFS.git
cd RFS

# Full build — assembles all ROMs, packages images, builds SD card image:
./build.sh

# Full build including reprocessing all MZF application files
# (only needed when files in MZF/ have changed):
./build.sh -m
build.sh esegue i seguenti passaggi in ordine:
  1. Compila cpmtools dai sorgenti (solo alla prima esecuzione) e lo aggiunge al PATH.
  2. tools/assemble_rfs.sh — assembla rfs.asm e rfs_mrom.asm in roms/rfs.rom e roms/rfs_mrom.rom.
  3. tools/assemble_cpm.sh — assembla il CBIOS CP/M 2.2 e CCP+BDOS in roms/*.rom.
  4. tools/assemble_roms.sh — assembla tutte le varianti del monitor e le applicazioni MZF. Gestisce le quattro varianti di build MS-BASIC scrivendo un BUILD_VERSION EQU in include/msbasic_buildversion.asm prima di ogni passata.
  5. tools/make_roms.sh — impacchetta i binari ROM e MZF in immagini Flash ROM per ciascun target.
  6. tools/make_cpmdisks.sh — crea le immagini disco CP/M in formato RAW (per scheda SD) e in CPC Extended Disk Format (per gli emulatori floppy).
  7. tools/make_sdcard.sh — combina 10 immagini di unita' RFS e 7 immagini disco CP/M nell'immagine finale della scheda SD.

File di output
Dopo una build riuscita la directory roms/ contiene:
File Chip Flash Descrizione
MROM_ROMDISK_256.bin Flash Monitor ROM Monitor ROM per RomDisk: SA-1510, 80c SA-1510, CBIOS CP/M, utilita’ mrom RFS, monitor 1Z-013A, tabelle opcode ASM/DASM, IPL e stringhe di messaggi su 16x4 KB pagine.
MROM_PICOZ80_256.bin Flash Monitor ROM Monitor ROM per picoZ80 (l’ordine dei banchi differisce da RomDisk).
USER_ROM_256.bin Flash User ROM 1 Banchi RFS 0–11, banchi CBIOS CP/M 12–15, immagine CP/M 2.2, applicazioni MZF impacchettate.
USER_ROM_II_256.bin Flash User ROM 2 Applicazioni MZF aggiuntive.
USER_ROM_III_256.bin Flash User ROM 3 Applicazioni MZF aggiuntive.
SFD700_256.bin Flash SFD-700 ROM AFI + firmware RFS + file system ROM.
SHARP_MZ80A_RFS_IMAGE_0–9.img Scheda SD Immagini individuali delle unita’ RFS (una per unita’ 0–9).
SHARP_MZ80A_RFS_CPM_IMAGE_1.img Scheda SD Immagine combinata: 10 unita’ RFS + 7 immagini disco CP/M. Scrivere questa sulla scheda SD.

Aggiungere applicazioni alle unita' ROM
I file applicativi in formato MZF devono essere convertiti in immagini binarie con padding a settore prima di essere inclusi nelle unita' ROM. Posizionare i file MZF nella sottodirectory appropriata sotto MZF/ quindi eseguire: 
tools/processMZFfiles.sh
Questo produce immagini con padding a settore da 128 byte e 256 byte in MZB/. Per scegliere quali applicazioni appaiono in ciascuna unita' ROM, modificare tools/make_roms.sh e regolare le chiamate addMZFToROMImageList: 
# Format: addMZFToROMImageList <ROMDISK> <SFD700> <picoZ80> <reserved> "<path>"
#
# Include in all builds:
addMZFToROMImageList 1 1 1 0 "${MZB_PATH}/Common/sa-5510_rfs.${SECTORSIZE}.bin"
#
# RomDisk and picoZ80 only (no SFD700 — needs SD card):
addMZFToROMImageList 1 0 1 0 "${MZB_PATH}/MZ-80A/defender.${SECTORSIZE}.bin"
Le applicazioni vengono impacchettate nell'ordine elencato, riempiendo prima la User ROM 1, poi la User ROM 2 e 3. Posizionare le applicazioni usate piu di frequente in cima all'elenco.

Riferimento degli strumenti di build
Strumento Descrizione
build.sh Script di build di livello superiore. Passare -m per rielaborare anche i file MZF.
tools/assemble_rfs.sh Assembla i moduli core di RFS.
tools/assemble_cpm.sh Assembla il CBIOS CP/M 2.2 e il kernel.
tools/assemble_roms.sh Assembla le varianti del monitor e i binari delle applicazioni MZF.
tools/make_roms.sh Impacchetta i binari in immagini Flash ROM.
tools/make_cpmdisks.sh Crea le immagini disco CP/M.
tools/make_sdcard.sh Combina le immagini nell’immagine finale della scheda SD.
tools/processMZFfiles.sh Converte i file MZF in binari con padding a settore in MZB/.
tools/mzftool.pl Crea, estrae e ispeziona immagini in formato MZF.
tools/sdtool Costruisce la directory della scheda SD RFS e la popola con i file.
tools/nasconv Converte le immagini di cassetta NASCOM in formato caricabile MZ-80A, rimappando i token MS-BASIC.
tools/glass.jar Assemblatore Z80 GLASS incluso (Java). Usato da tutti gli script di assemblaggio.
tools/MZFD/MZFDTool Crea e gestisce immagini floppy disk raw per l’FDC MZ-700. Comandi: format, dir, add, extract, boot. Immagine predefinita: MZ700.img.
tools/MZQD/MZQDTool Crea e gestisce immagini QD per il sistema Quick Disk MZ-700. Comandi: format, dir, add. Immagine predefinita: MZ700.qd.
cpmtools/ Sorgenti di cpmcp, cpmls, cpmrm, ecc. Compilati alla prima build.

Risorsa Link
Pagina del progetto RFS /it/sharpmz-upgrades-rfs/
Manuale utente RFS /it/sharpmz-upgrades-rfs-usermanual/
Guida per sviluppatori RFS /it/sharpmz-upgrades-rfs-developersguide/
Galleria RFS /it/sharpmz-upgrades-rfs-gallery/
Note CP/M su MZ-80A Incluse in _pages/MZ80A_RFS_CPM_README.md
Guida tecnica SFD-700 mkII /it/sfd700-technicalguide/
Guida tecnica picoZ80 /it/picoz80-technicalguide/
Assemblatore Z80 GLASS Incluso in tools/glass.jar