Systeme de fichiers ROM (RFS)

Presentation

Moniteur RFS

Si la mise a niveau Kuma 40/80 colonnes ou le Video Module est installe, taper 4 passe en affichage 40 colonnes et 8 passe en affichage 80 colonnes. En mode 80 colonnes, les commandes de listing (IC / IR) affichent quatre colonnes.

Applications ameliorees

Sharp BASIC SA-5510

Voir Organisation de la carte SD ci-dessous pour la disposition par defaut des lecteurs.

Microsoft BASIC

• MS-BASIC(MZ-80A) — pour le materiel MZ-80A original, stockage sur cassette uniquement.
• MS-BASIC(RFS40) — RFS avec affichage 40 colonnes ; ajoute les commandes carte SD, CLOAD, CSAVE, DIR.
• MS-BASIC(RFS80) — RFS avec affichage 80 colonnes ; ajoute les commandes carte SD, CLOAD, CSAVE, DIR.

Chaque variante apparait sur le lecteur ROM et le lecteur SD de RFS. Consultez le NASCOM Basic Manual pour l’ensemble complet des commandes standard. Le tableau ci-dessous liste les extensions ajoutees pour RFS.

Convertisseur d'image cassette 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)

Architecture logicielle

Systeme de build

Prerequis

L’assembleur GLASS Z80 (glass.jar) est inclus dans le repertoire tools/ — aucune installation separee n’est necessaire.

Configuration et build automatises (recommande)

macOS / Linux / WSL — setup_RFS.sh

chmod +x setup_RFS.sh
./setup_RFS.sh

Windows 10 / 11 — setup_RFS_windows_native.ps1 (recommande — natif, sans WSL). Depuis une invite PowerShell :

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

Le script natif utilise winget pour installer Git for Windows (qui fournit bash, coreutils, perl et curl) et une Temurin JRE (Java, pour l’assembleur GLASS), clone le depot, recupere le bundle de contenu et execute ./build.sh via Git Bash — sans WSL, Docker ni redemarrage. Le build RFS ne necessite aucun compilateur C sous Windows car deux outils hote precompiles (tools/cpmcp.exe et tools/sdtool.exe) sont fournis.

Windows 10 / 11 — setup_RFS_windows.ps1 (alternative — compile dans WSL2 / Ubuntu). Depuis un PowerShell Administrateur :

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

Cette variante WSL installe WSL2 + Ubuntu s’ils ne sont pas deja presents (ceci necessite un redemarrage unique — redemarrez, lancez Ubuntu une fois depuis le menu Demarrer pour creer votre nom d’utilisateur/mot de passe Linux, puis relancez le script), puis execute setup_RFS.sh dans Ubuntu. Preferez le script natif ci-dessus sauf si vous voulez specifiquement un environnement WSL.

Questions posees par la configuration, et que faire

Chaque invite comporte une valeur par defaut sure entre crochets — la lettre en majuscule est la valeur par defaut, donc appuyer sur Entree l’accepte. Les invites apparaissent dans cet ordre :

Windows uniquement (dans PowerShell, avant le lancement de la configuration Linux) :

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

Il se peut aussi qu’on vous demande votre mot de passe sudo (installation de paquets) et vos identifiants git si vous avez choisi un depot prive.

Apres la configuration — recompiler

Lorsque la configuration se termine, elle affiche le chemin de la copie de travail. Pour recompiler ulterieurement :

cd ~/RFS                 # ou le repertoire que vous avez choisi
source ./rfs_env.sh      # macOS uniquement (ajoute GNU coreutils + le JRE au PATH) ; sans effet ailleurs
./build.sh -m            # PREMIER build : traiter MZF -> MZB, puis tout compiler
./build.sh               # builds ulterieurs (ne relancez -m que si les sources MZF changent)
./build.sh -h            # lister les variantes et options

Sous Windows, ouvrez le terminal Ubuntu (menu Demarrer → “Ubuntu”, ou tapez wsl dans PowerShell) et executez les memes commandes dans ~/RFS. Les images ROM apparaissent dans ~/RFS/roms.

build.sh compile toutes les variantes materielles par defaut ; passez un ou plusieurs noms de variantes (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k, ou all) pour ne compiler que celles-ci. Selectionner une variante configure tout automatiquement — aucune edition de source necessaire. Options : -m (traiter les MZF), -s (ignorer l’assemblage partage), -c (nettoyer), -v (verbeux), -h (aide).

Avance : indicateurs de cible de build

Pour la plupart des builds, vous n’avez pas besoin de cette section — selectionner une variante avec build.sh (ci-dessus) configure tout automatiquement. Le mecanisme sous-jacent est un ensemble d’indicateurs dans asm/include/rfs_definitions.asm ; exactement un des suivants est mis a 1 (tous les autres a 0) pour une cible donnee, ce que build.sh fait pour vous par variante. Ne les editez a la main que pour une configuration personnalisee :

Indicateurs optionnels supplementaires dans le meme fichier :

Build manuel et ce que fait build.sh

Si vous preferez ne pas utiliser le script de configuration (ou si vous scriptez un build CI), vous pouvez cloner et compiler directement — vous devez toujours avoir les prerequis installes et, sur un clone autonome neuf, recuperer vous-meme les images de contenu (ou executer setup_RFS.sh, qui le fait pour vous) :

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

# Build complet (assemble tous les ROMs, empaquette les images ROM, cree l'image de carte SD) :
./build.sh

# Build complet incluant le retraitement de tous les fichiers d'application MZF
# (necessaire uniquement lorsque les fichiers source MZF dans MZF/ ont change) :
./build.sh -m

build.sh execute les etapes suivantes dans l’ordre :

1. Compile cpmtools depuis les sources (premier lancement uniquement) et ajoute le resultat au PATH.
2. tools/assemble_rfs.sh — assemble rfs.asm et rfs_mrom.asm en roms/rfs.rom et roms/rfs_mrom.rom.
3. tools/assemble_cpm.sh — assemble le CBIOS CP/M 2.2 (cbios.asm, cbios_bank1–4.asm, cpm22.asm) en roms/*.rom.
4. tools/assemble_roms.sh — assemble toutes les variantes du moniteur (SA-1510, 80c SA-1510, 1Z-013A, variantes hi-load, version Kuma, IPL) et les fichiers d’application MZF (SA-5510, variantes MS-BASIC, etc.) dans roms/ et MZB/.
5. tools/make_roms.sh — empaquette les ROMs assemblees et les applications MZF en images Flash ROM (voir Fichiers de sortie ci-dessous).
6. tools/make_cpmdisks.sh — cree les images de disques CP/M en format RAW et CPC Extended Disk Format pour chacun des ensembles de lecteurs CP/M pre-remplis.
7. tools/make_sdcard.sh — assemble l’image finale de carte SD combinant 10 images de lecteurs RFS et 7 images de disques CP/M.

Les scripts individuels peuvent egalement etre executes directement depuis le repertoire tools/ pour des builds partiels.

Fichiers de sortie

Apres un build reussi, le repertoire roms/ contient :

Programmation des Flash ROMs

Les images ROM sont ecrites sur des puces Flash RAM SST39SF040 (512 Ko) a l’aide d’un programmeur TL866 ou compatible :

# 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

Ecriture de l'image de carte SD

Ecrivez l’image de carte SD combinee directement sur la carte SD avec dd :

# Remplacez /dev/sdX par votre peripherique de carte SD :
dd if=roms/SHARP_MZ80A_RFS_CPM_IMAGE_1.img of=/dev/sdX bs=512
sync

Aucun partitionnement requis. L’image SDCFS commence au secteur 0. Inserez la carte SD dans le lecteur sur la carte RomDisk.

Ajout d'applications aux lecteurs ROM

Les applications stockees dans les lecteurs Flash ROM doivent d’abord etre converties du format MZF en images binaires alignees par secteur. Placez les fichiers MZF dans le sous-repertoire approprie sous MZF/ et executez :

tools/processMZFfiles.sh

Cela convertit tous les fichiers MZF en images alignees par secteur de 128 octets et 256 octets dans MZB/. Ils sont ensuite automatiquement pris en charge par make_roms.sh.

Pour choisir quelles applications apparaissent dans chaque lecteur ROM, editez tools/make_roms.sh et ajustez les appels addMZFToROMImageList. Chaque appel prend quatre indicateurs (inclure dans le build ROMDISK, inclure dans le build SFD700, inclure dans le build picoZ80, reserve) et le chemin vers le binaire sectorise :

# Format :
#   addMZFToROMImageList  <ROMDISK>  <SFD700>  <picoZ80>  <reserved>  "<MZB path>"
#
# Exemple — inclure dans tous les builds :
addMZFToROMImageList 1 1 1 0 "${MZB_PATH}/Common/sa-5510_rfs.${SECTORSIZE}.bin"

# Exemple — RomDisk et picoZ80 uniquement :
addMZFToROMImageList 1 0 1 0 "${MZB_PATH}/MZ-80A/defender.${SECTORSIZE}.bin"

Les applications sont empaquetees dans l’ordre indique, remplissant d’abord User ROM 1, puis User ROM 2 et 3. Placez les applications que vous souhaitez toujours disponibles en haut de la liste.

Reference des outils de build

SD Card Filing System

Structure SDCFS

Chaque bloc de fichier a une taille fixe de 64 Ko, correspondant a la taille maximale du bloc CMT (cassette). Cela simplifie la disposition et permet de lire ou d’ecrire les fichiers exactement comme s’ils etaient sur bande, permettant des operations de copie SD-CMT transparentes.

Disposition de la carte 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  └─────────────────────────────────────────────────────────────┘
                  ...  (les lecteurs RFS 1–8 suivent le meme schema)
09012000   48090  ┌─────────────────────────────────────────────────────────────┐
                  │  RFS DRIVE 9                                                │
0A013FFF   5009F  └─────────────────────────────────────────────────────────────┘
                  ... remplissage jusqu'a la limite de 256 Mo ...
10000000   80000  ┌─────────────────────────────────────────────────────────────┐
                  │  CP/M DISK IMAGE 0   (16 MB, 32 sectors × 1024 tracks)     │
11000000   88000  ├─────────────────────────────────────────────────────────────┤
                  │  CP/M DISK IMAGE 1                                          │
                  │  ...                                                        │
XX000000          │  CP/M DISK IMAGE n                                          │
                  └─────────────────────────────────────────────────────────────┘

Organisation de la carte SD

L’image de carte SD construite par les outils du depot est pre-remplie comme suit :

Manuels

Remerciements

Licences

La licence publique generale GNU v3