Sistema de archivos ROM (RFS)

Descripcion general

Monitor RFS

Si la actualizacion Kuma 40/80 columnas o el Video Module esta instalado, escribir 4 cambia a la visualizacion de 40 columnas y 8 cambia a la visualizacion de 80 columnas. En modo de 80 columnas, los comandos de listado de directorio (IC / IR) muestran cuatro columnas.

Aplicaciones mejoradas

Sharp BASIC SA-5510

Vease Organizacion de la tarjeta SD mas abajo para la disposicion predeterminada de las unidades.

Microsoft BASIC

• MS-BASIC(MZ-80A) — para hardware MZ-80A original, solo almacenamiento en casete.
• MS-BASIC(RFS40) — RFS con pantalla de 40 columnas; agrega tarjeta SD, CLOAD, CSAVE, DIR.
• MS-BASIC(RFS80) — RFS con pantalla de 80 columnas; agrega tarjeta SD, CLOAD, CSAVE, DIR.

Cada variante aparece en la unidad ROM y la unidad SD de RFS. Consulte el NASCOM Basic Manual para el conjunto completo de comandos estandar. La tabla siguiente enumera las extensiones agregadas para RFS.

Convertidor de imagen de casete 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)

Arquitectura de software

Sistema de compilacion

Requisitos previos

El ensamblador GLASS Z80 (glass.jar) esta incluido en el directorio tools/ — no se necesita instalacion separada.

Configuracion y compilacion automatizada (recomendado)

macOS / Linux / WSL — setup_RFS.sh

chmod +x setup_RFS.sh
./setup_RFS.sh

Windows 10 / 11 — setup_RFS_windows_native.ps1 (recomendado — nativo, sin WSL). Desde un simbolo de PowerShell:

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

El script nativo usa winget para instalar Git for Windows (que proporciona bash, coreutils, perl y curl) y un Temurin JRE (Java, para el ensamblador GLASS), clona el repo, obtiene el paquete de contenido y ejecuta ./build.sh a traves de Git Bash — sin necesidad de WSL, Docker ni reinicio. El build de RFS no necesita compilador C en Windows porque se incluyen dos herramientas de host precompiladas (tools/cpmcp.exe y tools/sdtool.exe).

Windows 10 / 11 — setup_RFS_windows.ps1 (alternativa — compila dentro de WSL2 / Ubuntu). Desde una PowerShell de Administrador:

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

Esta variante WSL instala WSL2 + Ubuntu si aun no estan presentes (esto requiere un reinicio unico — reinicie, inicie Ubuntu una vez desde el Menu Inicio para crear su nombre de usuario/contrasena de Linux, y luego vuelva a ejecutar el script), y luego ejecuta setup_RFS.sh dentro de Ubuntu. Prefiera el script nativo de arriba a menos que quiera especificamente un entorno WSL.

Preguntas que hace la configuracion, y que hacer

Cada indicacion tiene un valor predeterminado seguro mostrado entre corchetes — la letra en mayuscula es el predeterminado, asi que pulsar Enter lo acepta. Las indicaciones aparecen en este orden:

Solo Windows (en PowerShell, antes de ejecutarse la configuracion de Linux):

macOS / Linux / WSL (en el shell de Linux / Ubuntu):

Tambien se le puede pedir su contrasena de sudo (instalacion de paquetes) y sus credenciales de git si eligio un repositorio privado.

Despues de la configuracion — compilar de nuevo

Cuando la configuracion finaliza, imprime la ruta de la copia. Para recompilar mas tarde:

cd ~/RFS                 # o el directorio que eligio
source ./rfs_env.sh      # solo macOS (anade GNU coreutils + el JRE al PATH); inofensivo en otros sistemas
./build.sh -m            # PRIMERA compilacion: procesa MZF -> MZB, luego compila todo
./build.sh               # compilaciones posteriores (vuelva a ejecutar -m solo cuando cambien los fuentes MZF)
./build.sh -h            # lista variantes y opciones

En Windows, abra la terminal de Ubuntu (Menu Inicio → “Ubuntu”, o escriba wsl en PowerShell) y ejecute los mismos comandos dentro de ~/RFS. Las imagenes ROM aparecen en ~/RFS/roms.

build.sh compila todas las variantes de hardware de forma predeterminada; pase uno o mas nombres de variante (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k, o all) para compilar solo esas. Seleccionar una variante lo configura todo automaticamente — no se necesita editar el codigo fuente. Opciones: -m (procesar MZF), -s (omitir ensamblaje compartido), -c (limpiar), -v (detallado), -h (ayuda).

Avanzado: indicadores de objetivo de compilacion

Para la mayoria de las compilaciones no necesita esta seccion — seleccionar una variante con build.sh (arriba) lo configura todo automaticamente. El mecanismo subyacente es un conjunto de indicadores en asm/include/rfs_definitions.asm; exactamente uno de los siguientes se establece a 1 (todos los demas a 0) para un objetivo dado, lo cual build.sh hace por usted segun la variante. Editelos a mano solo para una configuracion personalizada:

Indicadores opcionales adicionales en el mismo archivo:

Compilacion manual y que hace build.sh

Si prefiere no usar el script de configuracion (o esta automatizando una compilacion CI), puede clonar y compilar directamente — aun debe tener los requisitos previos instalados y, en una copia independiente nueva, descargar usted mismo las imagenes de contenido (o ejecutar setup_RFS.sh, que lo hace por usted):

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

# Compilacion completa (ensambla todas las ROM, empaqueta imagenes ROM, crea imagen de tarjeta SD):
./build.sh

# Compilacion completa incluyendo reprocesamiento de todos los archivos de aplicacion MZF
# (solo necesario cuando los archivos fuente MZF en MZF/ han cambiado):
./build.sh -m

build.sh ejecuta los siguientes pasos en orden:

1. Compila cpmtools desde el codigo fuente (solo en la primera ejecucion) y agrega el resultado al PATH.
2. tools/assemble_rfs.sh — ensambla rfs.asm y rfs_mrom.asm en roms/rfs.rom y roms/rfs_mrom.rom.
3. tools/assemble_cpm.sh — ensambla el CBIOS CP/M 2.2 (cbios.asm, cbios_bank1–4.asm, cpm22.asm) en roms/*.rom.
4. tools/assemble_roms.sh — ensambla todas las variantes del monitor (SA-1510, 80c SA-1510, 1Z-013A, variantes hi-load, version Kuma, IPL) y los archivos de aplicacion MZF (SA-5510, variantes MS-BASIC, etc.) en roms/ y MZB/.
5. tools/make_roms.sh — empaqueta las ROM ensambladas y aplicaciones MZF en imagenes Flash ROM (vease Archivos de salida mas abajo).
6. tools/make_cpmdisks.sh — crea imagenes de disco CP/M en formato RAW y CPC Extended Disk Format para cada uno de los conjuntos de unidades CP/M pre-poblados.
7. tools/make_sdcard.sh — ensambla la imagen final de tarjeta SD combinando 10 imagenes de unidad RFS y 7 imagenes de disco CP/M.

Los scripts individuales tambien pueden ejecutarse directamente desde el directorio tools/ para compilaciones parciales.

Archivos de salida

Despues de una compilacion exitosa, el directorio roms/ contiene:

Programacion de las Flash ROM

Las imagenes ROM se escriben en chips Flash RAM SST39SF040 (512 KB) usando un programador TL866 o compatible:

# Monitor ROM (compilacion 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

Escritura de la imagen de tarjeta SD

Escriba la imagen combinada de tarjeta SD directamente en la tarjeta SD con dd:

# Reemplace /dev/sdX con su dispositivo de tarjeta SD:
dd if=roms/SHARP_MZ80A_RFS_CPM_IMAGE_1.img of=/dev/sdX bs=512
sync

No se requiere particionamiento. La imagen SDCFS comienza en el sector 0. Inserte la tarjeta SD en el lector de la tarjeta RomDisk.

Agregar aplicaciones a las unidades ROM

Las aplicaciones almacenadas en las unidades Flash ROM deben primero convertirse del formato MZF a imagenes binarias alineadas por sector. Coloque los archivos MZF en el subdirectorio apropiado bajo MZF/ y ejecute:

tools/processMZFfiles.sh

Esto convierte todos los archivos MZF en imagenes alineadas por sector de 128 bytes y 256 bytes almacenadas en MZB/. Luego son recogidas automaticamente por make_roms.sh.

Para elegir que aplicaciones aparecen en cada unidad ROM, edite tools/make_roms.sh y ajuste las llamadas addMZFToROMImageList. Cada llamada toma cuatro indicadores (incluir en compilacion ROMDISK, incluir en compilacion SFD700, incluir en compilacion picoZ80, reservado) y la ruta al binario alineado por sector:

# Format:
#   addMZFToROMImageList  <ROMDISK>  <SFD700>  <picoZ80>  <reserved>  "<MZB path>"
#
# Example — include in all builds:
addMZFToROMImageList 1 1 1 0 "${MZB_PATH}/Common/sa-5510_rfs.${SECTORSIZE}.bin"

# Example — RomDisk and picoZ80 only:
addMZFToROMImageList 1 0 1 0 "${MZB_PATH}/MZ-80A/defender.${SECTORSIZE}.bin"

Las aplicaciones se empaquetan en el orden listado, llenando primero la User ROM 1, luego la User ROM 2 y 3. Coloque las aplicaciones que siempre quiera tener disponibles al principio de la lista.

Referencia de herramientas de compilacion

SD Card Filing System

Estructura SDCFS

Cada bloque de archivo tiene un tamano fijo de 64 KB, correspondiente al tamano maximo del bloque CMT (cinta). Esto mantiene el diseno simple y permite leer o escribir archivos exactamente como si estuvieran en cinta, habilitando operaciones de copia SD-CMT transparentes.

Disposicion de la tarjeta 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  └─────────────────────────────────────────────────────────────┘
                  ...  (las unidades RFS 1–8 siguen el mismo patron)
09012000   48090  ┌─────────────────────────────────────────────────────────────┐
                  │  RFS DRIVE 9                                                │
0A013FFF   5009F  └─────────────────────────────────────────────────────────────┘
                  ... relleno hasta el limite de 256 MB ...
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                                          │
                  └─────────────────────────────────────────────────────────────┘

Organizacion de la tarjeta SD

La imagen de tarjeta SD construida por las herramientas del repositorio esta pre-poblada de la siguiente manera:

Manuales

Agradecimientos

Licencias

La Licencia Publica General GNU v3