Sistema di archiviazione ROM (RFS)

Panoramica

Monitor RFS

Se e installato l’upgrade Kuma 40/80 colonne o il Video Module, digitando 4 si passa alla visualizzazione a 40 colonne e 8 alla visualizzazione a 80 colonne. In modalita 80 colonne i comandi di elenco directory (IC / IR) visualizzano quattro colonne.

Applicazioni aggiornate

Sharp BASIC SA-5510

Vedere Organizzazione della scheda SD di seguito per il layout predefinito delle unita.

Microsoft BASIC

• MS-BASIC(MZ-80A) — per hardware MZ-80A originale, solo storage su cassetta.
• MS-BASIC(RFS40) — RFS con display a 40 colonne; aggiunge comandi scheda SD, CLOAD, CSAVE, DIR.
• MS-BASIC(RFS80) — RFS con display a 80 colonne; aggiunge comandi scheda SD, CLOAD, CSAVE, DIR.

Ogni variante appare sull’unita ROM RFS e sull’unita SD. Consultare il NASCOM Basic Manual per il set completo di comandi standard. La tabella seguente elenca le estensioni aggiunte per RFS.

Convertitore di immagine cassetta NASCOM

nasconv v1.0

Required:
  -i | --image  <file>   Cassette image file to convert.
  -o | --output <file>   Output file for converted BASIC data.

Options:
  -l | --loadaddr <addr> MZ-80A BASIC start address.
  -n | --nasaddr  <addr> Original NASCOM BASIC start address.
  -h | --help            Show this help.
  -v | --verbose         Verbose output.

Example:
  nasconv --image 3dnc.cas --output 3dnc.bas \
          --nasaddr 0x10fa --loadaddr 0x4341

BASIC MZ-5Z008 (Quick Disk)

BASIC MZ-2Z009E (Floppy Disk)

Architettura software

Sistema di build

Prerequisiti

L’assemblatore GLASS Z80 (glass.jar) e incluso nella directory tools/ — non e necessaria un’installazione separata.

Setup e build automatizzati (consigliato)

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 (che fornisce bash, coreutils, perl e curl) e una Temurin JRE (Java, per l’assemblatore GLASS), clona il repo, scarica il bundle dei contenuti ed esegue ./build.sh tramite Git Bash — senza WSL, Docker o riavvio. La build RFS non richiede un compilatore C su Windows perche due strumenti host precompilati (tools/cpmcp.exe e tools/sdtool.exe) sono inclusi.

Windows 10 / 11 — setup_RFS_windows.ps1 (alternativa — compila all’interno di 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 (questo richiede un riavvio una tantum — riavviate, avviate Ubuntu una volta dal menu Start per creare il vostro nome utente/password Linux, quindi rieseguite lo script), poi esegue setup_RFS.sh all’interno di Ubuntu. Preferite lo script nativo sopra a meno che non desideriate specificamente un ambiente WSL.

Domande poste dal setup, e cosa fare

Ogni richiesta ha un valore predefinito sicuro mostrato tra parentesi — la lettera maiuscola e il valore predefinito, quindi premendo Invio lo si accetta. Le richieste compaiono in questo ordine:

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

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

Potrebbe inoltre esservi richiesta la password sudo (installazione dei pacchetti) e le vostre credenziali git se avete scelto un repository privato.

Dopo il setup — compilare di nuovo

Al termine il setup stampa il percorso del checkout. Per ricompilare in seguito:

cd ~/RFS                 # o la directory che avete scelto
source ./rfs_env.sh      # solo macOS (aggiunge GNU coreutils + la JRE al PATH); innocuo altrove
./build.sh -m            # PRIMA build: elabora MZF -> MZB, poi compila tutto
./build.sh               # build successive (rieseguire -m solo quando i sorgenti MZF cambiano)
./build.sh -h            # elenca varianti e opzioni

Su Windows, aprite il terminale Ubuntu (menu Start → “Ubuntu”, oppure digitate wsl in PowerShell) ed eseguite gli stessi comandi in ~/RFS. Le immagini ROM compaiono in ~/RFS/roms.

build.sh compila tutte le varianti hardware per impostazione predefinita; passate uno o piu nomi di variante (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k, oppure all) per compilare solo quelle. La selezione di una variante configura tutto automaticamente — nessuna modifica ai sorgenti necessaria. Opzioni: -m (elabora MZF), -s (salta l’assemblaggio condiviso), -c (clean), -v (verbose), -h (help).

Avanzato: flag del target di build

Per la maggior parte delle build non serve questa sezione — selezionare una variante con build.sh (sopra) configura tutto automaticamente. Il meccanismo sottostante e un insieme di flag in asm/include/rfs_definitions.asm; esattamente uno dei seguenti viene impostato a 1 (tutti gli altri a 0) per un dato target, cosa che build.sh fa per voi in base alla variante. Modificateli a mano solo per una configurazione personalizzata:

Flag opzionali aggiuntivi nello stesso file:

Build manuale e cosa fa build.sh

Se preferite non usare lo script di setup (o state automatizzando una build CI), potete clonare e compilare direttamente — dovete comunque 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

# Build completa (assembla tutte le ROM, confeziona le immagini ROM, crea l'immagine della scheda SD):
./build.sh

# Build completa inclusa la rielaborazione di tutti i file applicazione MZF
# (necessario solo quando i file sorgente MZF in MZF/ sono cambiati):
./build.sh -m

build.sh esegue i seguenti passaggi nell’ordine:

1. Compila cpmtools dai sorgenti (solo alla prima esecuzione) e aggiunge il risultato 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 (cbios.asm, cbios_bank1–4.asm, cpm22.asm) in roms/*.rom.
4. tools/assemble_roms.sh — assembla tutte le varianti del monitor (SA-1510, 80c SA-1510, 1Z-013A, varianti hi-load, versione Kuma, IPL) e i file applicazione MZF (SA-5510, varianti MS-BASIC, ecc.) in roms/ e MZB/.
5. tools/make_roms.sh — confeziona le ROM assemblate e le applicazioni MZF in immagini Flash ROM (vedere File di output di seguito).
6. tools/make_cpmdisks.sh — crea immagini disco CP/M in formato RAW e CPC Extended Disk Format per ciascuno dei set di unita CP/M pre-popolati.
7. tools/make_sdcard.sh — assembla l’immagine finale della scheda SD combinando 10 immagini di unita RFS e 7 immagini disco CP/M.

Gli script individuali possono anche essere eseguiti direttamente dalla directory tools/ per build parziali.

File di output

Dopo una build riuscita la directory roms/ contiene:

Programmazione delle Flash ROM

Le immagini ROM vengono scritte su chip Flash RAM SST39SF040 (512 KB) utilizzando un programmatore TL866 o compatibile:

# Monitor ROM (build RomDisk):
minipro --infoic /path/to/minipro/infoic.xml -p SST39SF040 -s -w roms/MROM_ROMDISK_256.bin

# User ROM 1:
minipro --infoic /path/to/minipro/infoic.xml -p SST39SF040 -s -w roms/USER_ROM_256.bin

# SFD-700:
minipro --infoic /path/to/minipro/infoic.xml -p SST39SF040 -s -w roms/SFD700_256.bin

Scrittura dell'immagine della scheda SD

Scrivere l’immagine combinata della scheda SD direttamente sulla scheda SD con dd:

# Sostituire /dev/sdX con il dispositivo della scheda SD:
dd if=roms/SHARP_MZ80A_RFS_CPM_IMAGE_1.img of=/dev/sdX bs=512
sync

Nessun partizionamento richiesto. L’immagine SDCFS inizia al settore 0. Inserire la scheda SD nel lettore sulla scheda RomDisk.

Aggiunta di applicazioni alle unita ROM

Le applicazioni memorizzate nelle unita Flash ROM devono prima essere convertite dal formato MZF in immagini binarie allineate per settore. Posizionare i file MZF nella sottodirectory appropriata sotto MZF/ ed eseguire:

tools/processMZFfiles.sh

Questo converte tutti i file MZF in immagini allineate per settore da 128 byte e 256 byte in MZB/. Vengono poi automaticamente presi in carico da make_roms.sh.

Per scegliere quali applicazioni appaiono in ogni unita ROM, modificare tools/make_roms.sh e regolare le chiamate addMZFToROMImageList:

# Formato:
#   addMZFToROMImageList  <ROMDISK>  <SFD700>  <picoZ80>  <reserved>  "<MZB path>"
#
# Esempio — includere in tutte le build:
addMZFToROMImageList 1 1 1 0 "${MZB_PATH}/Common/sa-5510_rfs.${SECTORSIZE}.bin"

# Esempio — solo RomDisk e picoZ80:
addMZFToROMImageList 1 0 1 0 "${MZB_PATH}/MZ-80A/defender.${SECTORSIZE}.bin"

Le applicazioni vengono compresse nell’ordine indicato, riempiendo prima User ROM 1, poi User ROM 2 e 3. Posizionare le applicazioni che si desidera sempre disponibili in cima alla lista.

Riferimento strumenti di build

SD Card Filing System

Struttura SDCFS

Ogni blocco file e di dimensione fissa 64 KB, corrispondente alla dimensione massima del blocco CMT (cassetta). Questo mantiene il layout semplice e permette di leggere o scrivere file esattamente come se fossero su nastro, consentendo operazioni di copia SD-CMT trasparenti.

Layout della scheda SD

ADDRESS    SECTOR   CONTENT
00000000   00000  +-------------------------------------------------------------+
                  |  RFS DRIVE 0                                                |
00000000   00000  |  Directory entry 000 (32 bytes)                             |
                  |  ...                                                        |
00001FE0   0000F  |  Directory entry 255 (32 bytes)                             |
00002000   00010  |  File block 0     (64 KB)                                   |
                  |  ...                                                        |
00FF2000   7FF90  |  File block 255   (64 KB)                                   |
01001FFF   8000F  +-------------------------------------------------------------+
                  ...  (le unita RFS 1–8 seguono lo stesso schema)
09012000   48090  +-------------------------------------------------------------+
                  |  RFS DRIVE 9                                                |
0A013FFF   5009F  +-------------------------------------------------------------+
                  ... riempimento fino al limite di 256 MB ...
10000000   80000  +-------------------------------------------------------------+
                  |  CP/M DISK IMAGE 0   (16 MB, 32 sectors x 1024 tracks)     |
11000000   88000  +-------------------------------------------------------------+
                  |  CP/M DISK IMAGE 1                                          |
                  |  ...                                                        |
XX000000          |  CP/M DISK IMAGE n                                          |
                  +-------------------------------------------------------------+

Organizzazione della scheda SD

L’immagine della scheda SD costruita dagli strumenti del repository e pre-popolata come segue:

Manuali

Ringraziamenti

Licenze

La GNU General Public License v3