ROM-Dateisystem (RFS)

Uebersicht

RFS-Monitor

Falls das Kuma 40/80-Spalten-Upgrade oder das Video Module installiert ist, schaltet die Eingabe von 4 in den 40-Spalten-Modus und 8 in den 80-Spalten-Modus. Im 80-Spalten-Modus zeigen die Verzeichnisbefehle (IC / IR) vier Spalten an.

Erweiterte Anwendungen

Sharp BASIC SA-5510

Siehe SD-Karten-Organisation unten fuer das Standard-Laufwerkslayout.

Microsoft BASIC

• MS-BASIC(MZ-80A) — fuer originale MZ-80A-Hardware, nur Kassettenspeicher.
• MS-BASIC(RFS40) — RFS mit 40-Spalten-Anzeige; fuegt SD-Karten-, CLOAD-, CSAVE-, DIR-Befehle hinzu.
• MS-BASIC(RFS80) — RFS mit 80-Spalten-Anzeige; fuegt SD-Karten-, CLOAD-, CSAVE-, DIR-Befehle hinzu.

Jede Variante erscheint auf dem RFS-ROM-Laufwerk und SD-Laufwerk. Den vollstaendigen Standard-Befehlssatz finden Sie im NASCOM Basic Manual. Die folgende Tabelle listet die fuer RFS hinzugefuegten Erweiterungen auf.

NASCOM-Kassettenimage-Konverter

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)

Software-Architektur

Build-System

Voraussetzungen

Der GLASS Z80-Assembler (glass.jar) ist im Verzeichnis tools/ enthalten — keine separate Installation erforderlich.

Automatisiertes Setup und Build (empfohlen)

macOS / Linux / WSL — setup_RFS.sh

chmod +x setup_RFS.sh
./setup_RFS.sh

Windows 10 / 11 — setup_RFS_windows_native.ps1 (empfohlen — nativ, kein WSL). In einer PowerShell-Eingabeaufforderung:

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

Das native Skript verwendet winget, um Git for Windows (das bash, coreutils, perl und curl bereitstellt) und eine Temurin JRE (Java, fuer den GLASS-Assembler) zu installieren, klont das Repository, holt das Inhaltspaket und fuehrt ./build.sh ueber Git Bash aus — ohne WSL, Docker oder Neustart. Der RFS-Build benoetigt unter Windows keinen C-Compiler, da zwei vorgefertigte Host-Werkzeuge (tools/cpmcp.exe und tools/sdtool.exe) mitgeliefert werden.

Windows 10 / 11 — setup_RFS_windows.ps1 (Alternative — baut innerhalb von WSL2 / Ubuntu). In einer Administrator-PowerShell:

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

Diese WSL-Variante installiert WSL2 + Ubuntu, falls sie noch nicht vorhanden sind (dies erfordert einen einmaligen Neustart — neu starten, Ubuntu einmal ueber das Startmenue starten, um Ihren Linux-Benutzernamen/Ihr Passwort anzulegen, dann das Skript erneut ausfuehren). Anschliessend fuehrt es setup_RFS.sh innerhalb von Ubuntu aus. Bevorzugen Sie das native Skript oben, sofern Sie nicht ausdruecklich eine WSL-Umgebung wuenschen.

Fragen, die das Setup stellt, und was zu tun ist

Jede Eingabeaufforderung hat einen sicheren Standardwert in Klammern — der Grossbuchstabe ist der Standard, sodass Druecken von Enter ihn uebernimmt. Die Eingabeaufforderungen erscheinen in dieser Reihenfolge:

Nur Windows (in PowerShell, bevor das Linux-Setup laeuft):

macOS / Linux / WSL (in der Linux-/Ubuntu-Shell):

Sie werden moeglicherweise auch nach Ihrem sudo-Passwort (Paketinstallation) und Ihren git-Anmeldedaten gefragt, falls Sie ein privates Repository gewaehlt haben.

Nach dem Setup — erneut bauen

Wenn das Setup abgeschlossen ist, gibt es den Checkout-Pfad aus. Um spaeter neu zu bauen:

cd ~/RFS                 # oder das von Ihnen gewaehlte Verzeichnis
source ./rfs_env.sh      # nur macOS (fuegt GNU coreutils + die JRE zum PATH hinzu); anderswo harmlos
./build.sh -m            # ERSTER Build: MZF -> MZB verarbeiten, dann alles bauen
./build.sh               # spaetere Builds (-m nur erneut, wenn sich MZF-Quellen aendern)
./build.sh -h            # Varianten und Optionen auflisten

Unter Windows oeffnen Sie das Ubuntu-Terminal (Startmenue → “Ubuntu” oder wsl in PowerShell eingeben) und fuehren dieselben Befehle in ~/RFS aus. Die ROM-Images erscheinen in ~/RFS/roms.

build.sh baut standardmaessig alle Hardware-Varianten; uebergeben Sie einen oder mehrere Variantennamen (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k oder all), um nur diese zu bauen. Die Auswahl einer Variante konfiguriert alles automatisch — keine Quellcode-Aenderungen noetig. Optionen: -m (MZF verarbeiten), -s (gemeinsame Assemblierung ueberspringen), -c (clean), -v (ausfuehrlich), -h (Hilfe).

Fortgeschritten: Build-Ziel-Flags

Fuer die meisten Builds benoetigen Sie diesen Abschnitt nicht — die Auswahl einer Variante mit build.sh (oben) konfiguriert alles automatisch. Der zugrunde liegende Mechanismus ist ein Satz von Flags in asm/include/rfs_definitions.asm; genau eines der folgenden wird fuer ein bestimmtes Ziel auf 1 gesetzt (alle anderen 0), was build.sh pro Variante fuer Sie erledigt. Bearbeiten Sie sie nur fuer eine benutzerdefinierte Konfiguration von Hand:

Zusaetzliche optionale Flags in derselben Datei:

Manueller Build und was build.sh tut

Wenn Sie das Setup-Skript nicht verwenden moechten (oder einen CI-Build skripten), koennen Sie direkt klonen und bauen — Sie muessen die Voraussetzungen weiterhin installiert haben und bei einem frischen, eigenstaendigen Klon die Inhalts-Images selbst holen (oder setup_RFS.sh ausfuehren, das dies fuer Sie erledigt):

git clone --recurse-submodules https://git.eaw.app/eaw/RFS.git
cd RFS

# Vollstaendiger Build (assembliert alle ROMs, verpackt ROM-Images, erstellt SD-Karten-Image):
./build.sh

# Vollstaendiger Build einschliesslich erneuter Verarbeitung aller MZF-Anwendungsdateien
# (nur erforderlich, wenn sich MZF-Quelldateien in MZF/ geaendert haben):
./build.sh -m

build.sh fuehrt die folgenden Schritte der Reihe nach aus:

1. Kompiliert cpmtools aus dem Quellcode (nur beim ersten Lauf) und fuegt das Ergebnis zum PATH hinzu.
2. tools/assemble_rfs.sh — assembliert rfs.asm und rfs_mrom.asm zu roms/rfs.rom und roms/rfs_mrom.rom.
3. tools/assemble_cpm.sh — assembliert das CP/M 2.2 CBIOS (cbios.asm, cbios_bank1–4.asm, cpm22.asm) zu roms/*.rom.
4. tools/assemble_roms.sh — assembliert alle Monitor-Varianten (SA-1510, 80c SA-1510, 1Z-013A, Hi-Load-Varianten, Kuma-Version, IPL) und MZF-Anwendungsdateien (SA-5510, MS-BASIC-Varianten usw.) in roms/ und MZB/.
5. tools/make_roms.sh — verpackt die assemblierten ROMs und MZF-Anwendungen in Flash-ROM-Images (siehe Ausgabedateien unten).
6. tools/make_cpmdisks.sh — erstellt CP/M-Disk-Images in RAW- und CPC Extended Disk-Format fuer jedes der vorbelegten CP/M-Laufwerkssets.
7. tools/make_sdcard.sh — stellt das endgueltige SD-Karten-Image aus 10 RFS-Laufwerks-Images und 7 CP/M-Disk-Images zusammen.

Die einzelnen Skripte koennen auch direkt aus dem Verzeichnis tools/ fuer Teil-Builds ausgefuehrt werden.

Ausgabedateien

Nach einem erfolgreichen Build enthaelt das Verzeichnis roms/:

Programmierung der Flash-ROMs

Die ROM-Images werden mit einem TL866 oder kompatiblen Programmer auf SST39SF040 (512 KB) Flash-RAM-Chips geschrieben:

# Monitor ROM (RomDisk-Build):
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

Beschreiben des SD-Karten-Images

Schreiben Sie das kombinierte SD-Karten-Image direkt mit dd auf die SD-Karte:

# Ersetzen Sie /dev/sdX durch Ihren SD-Karten-Geraeteknoten:
dd if=roms/SHARP_MZ80A_RFS_CPM_IMAGE_1.img of=/dev/sdX bs=512
sync

Keine Partitionierung erforderlich. Das SDCFS-Image beginnt bei Sektor 0. Setzen Sie die SD-Karte in den Leser auf der RomDisk-Platine ein.

Anwendungen zu den ROM-Laufwerken hinzufuegen

Anwendungen, die in den Flash-ROM-Laufwerken gespeichert werden sollen, muessen zuerst vom MZF-Format in sektorausgerichtete Binaer-Images konvertiert werden. Platzieren Sie die MZF-Dateien im entsprechenden Unterverzeichnis unter MZF/ und fuehren Sie aus:

tools/processMZFfiles.sh

Dies konvertiert alle MZF-Dateien in 128-Byte- und 256-Byte-sektorausgerichtete Images in MZB/. Sie werden dann automatisch von make_roms.sh erfasst.

Um auszuwaehlen, welche Anwendungen in jedem ROM-Laufwerk erscheinen, bearbeiten Sie tools/make_roms.sh und passen Sie die addMZFToROMImageList-Aufrufe an. Jeder Aufruf nimmt vier Flags (in ROMDISK-Build einschliessen, in SFD700-Build einschliessen, in picoZ80-Build einschliessen, reserviert) und den Pfad zum sektorierten Binaer:

# Format:
#   addMZFToROMImageList  <ROMDISK>  <SFD700>  <picoZ80>  <reserved>  "<MZB path>"
#
# Beispiel — in allen Builds einschliessen:
addMZFToROMImageList 1 1 1 0 "${MZB_PATH}/Common/sa-5510_rfs.${SECTORSIZE}.bin"

# Beispiel — nur RomDisk und picoZ80:
addMZFToROMImageList 1 0 1 0 "${MZB_PATH}/MZ-80A/defender.${SECTORSIZE}.bin"

Anwendungen werden in der aufgefuehrten Reihenfolge gepackt, wobei zuerst User ROM 1 gefuellt wird, dann User ROM 2 und 3. Platzieren Sie Anwendungen, die Sie immer verfuegbar haben moechten, am Anfang der Liste.

Build-Werkzeuge Referenz

SD Card Filing System

SDCFS-Struktur

Jeder Dateiblock ist fest 64 KB gross, entsprechend der maximalen CMT (Band)-Blockgroesse. Dies haelt das Layout einfach und ermoeglicht es, Dateien genau so zu lesen oder zu schreiben, als waeren sie auf Band, was transparente SD-CMT-Kopieroperationen ermoeglicht.

SD-Karten-Layout

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  +-------------------------------------------------------------+
                  ...  (RFS-Laufwerke 1–8 folgen dem gleichen Muster)
09012000   48090  +-------------------------------------------------------------+
                  |  RFS DRIVE 9                                                |
0A013FFF   5009F  +-------------------------------------------------------------+
                  ... Auffuellung bis zur 256 MB-Grenze ...
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                                          |
                  +-------------------------------------------------------------+

SD-Karten-Organisation

Das von den Repository-Werkzeugen erstellte SD-Karten-Image ist wie folgt vorbelegt:

Handbuecher

Danksagungen

Lizenzen

Die GNU General Public License v3