Sistema de archivos ROM (RFS) — Guia tecnica

Guia tecnica RFS

Esta guia documenta la integracion de hardware del Rom Filing System, la arquitectura de memoria, la disposicion de los modulos de software, el diseno del SD Card Filing System, la implementacion de CP/M y el sistema de compilacion completo. Esta destinada a usuarios que desean comprender como funciona RFS a nivel de sistema, portar RFS a nuevo hardware o realizar una compilacion completa desde el codigo fuente.
Para el uso diario y la referencia de comandos del monitor, vease el Manual del usuario. Para los recorridos del codigo fuente en ensamblador Z80, vease la Guia del desarrollador.

Plataformas de hardware

RFS soporta cuatro plataformas de hardware. Cada una se selecciona en tiempo de compilacion mediante un indicador en asm/include/rfs_definitions.asm. Las imagenes binarias resultantes difieren en la disposicion de bancos, el conjunto de caracteristicas y las direcciones ROM utilizadas.

Tarjeta RomDisk
El objetivo RFS original y mas capaz. El PCB RomDisk se conecta al slot de expansion del Sharp MZ-80A y proporciona:
  • Hasta 4 x 512 KB SST39SF040 Flash RAM — reemplaza la ROM del Monitor y proporciona tres chips de User ROM, ofreciendo hasta 2 MB de almacenamiento ROM basado en Flash.
  • 512 KB de RAM estatica — disponible como espacio de trabajo paginado adicional (uso futuro).
  • Lector de tarjetas SDXC con interfaz SPI hardware (tarjetas v2+) o SPI por bit-bang software (tarjetas v1, usando el puerto paralelo de impresora).
  • Un latch codificado (tarjetas v2.0+) que protege los registros de control de bancos — el latch solo se abre tras una secuencia fija de lecturas a los 8 bytes superiores del rango de direcciones de la User ROM (0xEFF8–0xEFFF), evitando conmutaciones de banco accidentales durante el funcionamiento normal.
El chip de ROM del Monitor (en 0x0000–0x0FFF en el MZ-80A) se reemplaza por un socket Flash RAM paginado adaptado para aparecer como una ventana de 4 KB hacia el chip completo de 512 KB. De forma similar, la User ROM (en 0xE800–0xEFFF) se reemplaza por una ventana paginada de 2 KB.

Interfaz de disquete SFD-700
La tarjeta de interfaz de disquete SFD-700 mkII incluye una Flash ROM de 512 KB. RFS ocupa paginas de esta Flash ROM junto al codigo de arranque AFI de disquete:
  • 0x00000–0x00FFF — ROM de arranque de disquete AFI del MZ-80A (original, necesaria para el truco de DRQ a 2 MHz).
  • 0x01000–0x01FFF — ROM de arranque de disquete AFI del MZ-700.
  • 0x02000–0x0BFFF — firmware RFS (10 x 2 KB de bancos de User ROM, equivalente a los bancos de User ROM 0–4).
  • 0x0C000 en adelante — sistema de archivos ROM (programas almacenados como imagenes MZF).
En la compilacion SFD-700, el codigo de la User ROM se ensambla para comenzar en 0xE000 y se alinea a 0xE300 (respetando el rango de I/O mapeado en memoria del MZ-700). No hay tarjeta SD; los comandos de tarjeta SD se excluyen de esta compilacion.

picoZ80
La tarjeta picoZ80 (reemplazo Z80 basado en RP2350) emula el mapa de memoria completo del MZ-80A en PSRAM y Flash. RFS se ejecuta dentro del espacio ROM emulado, usando las mismas direcciones de banco que la compilacion RomDisk. La picoZ80 proporciona su propio almacenamiento de tarjeta SD conectado por SPI, de modo que el conjunto completo de caracteristicas de RomDisk (unidades de tarjeta SD, copia cinta-a-SD, etc.) esta disponible.

RFS se ejecuta bajo cualquiera de las personalidades de maquina que la picoZ80 presenta al anfitrion. Ademas del MZ-80A, esto ahora incluye la personalidad Sharp MZ-80K, que puede usar las mismas tarjetas de interfaz Sharp que el MZ-80A (RFS, MZ80AFI, MZ-1E14/E19, MZ-1R12/R18/R37, PIO-3034) asi como su propio controlador de disquete nativo MZ-80FD (T3444M). Con una tarjeta MZ80AFI, el CBIOS CP/M de RFS detecta automaticamente los discos CP/M originales del MZ-80K (sectores de 128 bytes, no invertidos) y los monta como unidades CP/M C:/D:.

Arquitectura de memoria

La CPU Z80 del Sharp MZ-80A direcciona 64 KB de memoria. RFS encaja todo su firmware en las dos ventanas ROM sin consumir nada de RAM, dejando libre el rango completo 0x1200–0xCFFF para programas de usuario.

Disposicion del espacio de direcciones 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)
─────────────────────────────────────────────────────────────────────

Bancos Monitor ROM (4 KB cada uno)
La ventana de la Monitor ROM en 0x0000–0x0FFF se conmuta entre 16 paginas almacenadas en el chip Flash de la Monitor ROM. De estas, tres paginas (bancos 6, 7 y 9) estan dedicadas a RFS — conteniendo respectivamente las tablas de opcodes del ensamblador/desensamblador Z80 y las cadenas de mensajes:
Banco Modulo Descripcion
0 monitor_sa1510.asm ROM monitor SA-1510 original — 40 columnas. El banco predeterminado al encender.
1 monitor_80c_sa1510.asm SA-1510 adaptado para pantalla de 80 columnas (requiere la mejora Kuma).
2 cbios.asm Kernel CBIOS CP/M 2.2 — reubicado aqui durante el arranque de CP/M.
3 rfs_mrom.asm Utilidades Monitor ROM RFS. Se ejecuta desde el espacio MROM para escanear y cargar archivos MZF almacenados en la Flash de la User ROM, ya que el codigo de la User ROM no puede paginarse a si mismo fuera.
4 monitor_1z-013a.asm Monitor MZ-1Z-013A (variante MZ-700 / MZ-1200).
5 monitor_80c_1z-013a.asm Monitor 1Z-013A adaptado para pantalla de 80 columnas.
6 rfs_mrom_bank6.asm Tabla de opcodes 1 del ensamblador/desensamblador Z80.
7 rfs_mrom_bank7.asm Tabla de opcodes 2 del ensamblador/desensamblador Z80.
8 ipl.asm Initial Program Loader.
9 rfs_mrom_bank9.asm Repositorio de cadenas de mensajes RFS.
10–15 — Reservado / libre.

Bancos User ROM (2 KB cada uno)
La ventana de la User ROM en 0xE800–0xEFFF se conmuta entre 16 bancos en los chips Flash de la User ROM — 12 bancos para RFS (bancos 0–11) y 4 bancos para el CBIOS CP/M (bancos 12–15):
Banco Modulo Descripcion
0 rfs.asm Punto de entrada principal RFS, despachador de comandos, tabla de comandos, infraestructura de conmutacion de bancos compartida por todos los bancos.
1 rfs_bank1.asm Funciones del controlador de disquete (FDC) — arranque de disquete (FL), directorio de disquete (FD), copia de disquete (FC), disquete-a-cinta (FD2T), cinta-a-disquete (T2FD) y seleccion de unidad. El conjunto completo de comandos FDC se ensambla en todas las compilaciones.
2 rfs_bank2.asm Controlador de tarjeta SD — driver SPI, inicializacion de tarjeta SD, directorio SDCFS y lectura/escritura de archivos. No se ensambla en la compilacion SFD-700 (sin hardware de tarjeta SD).
3 rfs_bank3.asm Utilidades de memoria del monitor — volcado hexadecimal (D), edicion de memoria (M), copia de memoria (CP), volcado de archivo de tarjeta SD (DUC), lectura/escritura de puerto I/O (IN / OUT). La copia cinta-a-SD (T2SD/SD2T) se incluye solo en las compilaciones RomDisk / picoZ80.
4 rfs_bank4.asm Controlador CMT (cassette) — carga, guardado y verificacion de cinta.
5 rfs_bank5.asm Funciones de utilidad general — impresion formateada, rutinas de cadenas, codigo auxiliar compartido.
6 rfs_bank6.asm Tabla de opcodes 1 del ensamblador/desensamblador Z80, funcion PRINTMSG e infraestructura de cadenas de mensajes.
7 rfs_bank7.asm Tabla de opcodes 2 del ensamblador/desensamblador Z80, desensamblador Z80 (DASM), prueba de memoria DRAM, prueba del timer 8253.
8 rfs_bank8.asm Ensamblador Z80 interactivo (ASM).
9 rfs_bank9.asm Directorio ROM, busqueda de archivos, funciones de carga e impresion (movidas del banco 0 para liberar espacio).
10 rfs_bank10.asm Reservado / libre.
11 rfs_bank11.asm Pantalla de ayuda.
12 cbios_bank1.asm CBIOS CP/M — funciones de audio, RTC, teclado y utilidades de bajo nivel.
13 cbios_bank2.asm CBIOS CP/M — driver de pantalla y emulacion de terminal ANSI.
14 cbios_bank3.asm CBIOS CP/M — driver de tarjeta SD (proporciona las unidades CP/M A:–G:).
15 cbios_bank4.asm CBIOS CP/M — controlador de disquete. Detecta automaticamente el tamano de sector mediante la tarjeta MZ80AFI (256 bytes del MZ-80A frente a 128 bytes del MZ-80K) y puede leer discos CP/M originales del MZ-80K directamente, asignandolos a las unidades CP/M C:/D:.

Mecanismo de conmutacion de bancos
Como el Z80 solo puede ver una porcion de 2 KB de la User ROM a la vez, cada banco contiene una copia del stub de conmutacion de bancos — un pequeno bloque fijo de codigo en una direccion conocida dentro de la ventana de 2 KB. Cuando el banco 0 necesita llamar a una rutina del banco 3:
  1. Escribe el numero del banco de destino en el registro de latch de bancos del hardware.
  2. Salta al punto de entrada conocido en el banco recien mapeado.
  3. Ejecuta la rutina requerida.
  4. Escribe el banco 0 de vuelta en el latch y retorna.
Este mecanismo significa que los 12 bancos RFS (12 x 2 KB = 24 KB) mas los 4 bancos CBIOS (4 x 2 KB = 8 KB) — 32 KB en total — son accesibles desde cualquier contexto de ejecucion, aunque solo 2 KB sean visibles a la vez. El stub de conmutacion de bancos ocupa los primeros 32 bytes de cada banco (0xE800–0xE81F), y la tabla de conmutacion de bancos comienza en 0xE800 + 0xB0. Es critico que ninguna instruccion de bucle abarque jamas el rango 0xEFF8–0xEFFF en las tarjetas RomDisk v2+, ya que esas direcciones disparan la secuencia de desbloqueo del latch codificado.

Arquitectura de software

La tabla completa de modulos — cada archivo fuente, su ROM de destino, banco y funcion:
Modulo ROM Banco Tamano Descripcion
rfs.asm User 0 2 KB Despachador de comandos, tabla de comandos, infraestructura de conmutacion de bancos.
rfs_bank1.asm User 1 2 KB Controlador de disquete — seleccion de unidad, arranque FDC, copia de disquete (FC), disquete-a-cinta (FD2T), cinta-a-disquete (T2FD) (RomDisk/picoZ80); solo salto AFI FDCK (SFD-700).
rfs_bank2.asm User 2 2 KB Controlador de tarjeta SD — SPI, directorio SDCFS, lectura/escritura de archivos. No se ensambla en la compilacion SFD-700.
rfs_bank3.asm User 3 2 KB Utilidades de memoria — D, M, CP, DUC, IN, OUT (todas las compilaciones); T2SD, SD2T (solo RomDisk / picoZ80).
rfs_bank4.asm User 4 2 KB Controlador CMT — carga, guardado, verificacion de cinta.
rfs_bank5.asm User 5 2 KB Utilidades generales — rutinas de impresion, auxiliares de cadenas.
rfs_bank6.asm User 6 2 KB Tabla de opcodes 1 del ensamblador/desensamblador Z80, funcion PRINTMSG, infraestructura de cadenas de mensajes.
rfs_bank7.asm User 7 2 KB Tabla de opcodes 2 del ensamblador/desensamblador Z80, DASM, prueba DRAM, prueba del timer.
rfs_bank8.asm User 8 2 KB Ensamblador Z80 interactivo (ASM).
rfs_bank9.asm User 9 2 KB Directorio ROM, busqueda de archivos, funciones de carga e impresion (movidas del banco 0).
rfs_bank10.asm User 10 2 KB Reservado / libre.
rfs_bank11.asm User 11 2 KB Pantalla de ayuda.
cbios_bank1.asm User 12 2 KB CBIOS CP/M — audio, RTC, teclado, utilidades de bajo nivel.
cbios_bank2.asm User 13 2 KB CBIOS CP/M — driver de pantalla, emulador de terminal ANSI.
cbios_bank3.asm User 14 2 KB CBIOS CP/M — driver de tarjeta SD (unidades CP/M A:–G:).
cbios_bank4.asm User 15 2 KB CBIOS CP/M — controlador de disquete.
monitor_sa1510.asm Monitor 0 4 KB ROM monitor SA-1510 original (40 columnas).
monitor_80c_sa1510.asm Monitor 1 4 KB SA-1510 adaptado para pantalla de 80 columnas.
cbios.asm Monitor 2 4 KB Kernel CBIOS CP/M 2.2 (reubicado a 0xC000 durante el arranque de CP/M).
rfs_mrom.asm Monitor 3 4 KB Utilidades Monitor ROM RFS — escaneo de ROM, carga de 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 adaptado para pantalla de 80 columnas.
rfs_mrom_bank6.asm Monitor 6 4 KB Tabla de opcodes 1 del ensamblador/desensamblador Z80.
rfs_mrom_bank7.asm Monitor 7 4 KB Tabla de opcodes 2 del ensamblador/desensamblador Z80.
ipl.asm Monitor 8 4 KB Initial Program Loader.
rfs_mrom_bank9.asm Monitor 9 4 KB Repositorio de cadenas de mensajes RFS.
CP/M 2.2 ofrece 47 KB de RAM de programa utilizable. El CCP y el BDOS residen en RAM y pueden ser sobrescritos por aplicaciones grandes (se recargan en el arranque en caliente). El CBIOS reside enteramente en el banco 2 de la Monitor ROM y en los bancos 12–15 de la User ROM, sin consumir RAM de programa.
La Monitor ROM tambien produce varias imagenes variantes adicionales en tiempo de compilacion: variantes de carga alta (hi-load) de SA-1510 y de 80c SA-1510 (usadas cuando la DRAM debe abarcar 0x0000–0xCFFF), y variantes Kuma-80 (seleccionadas mediante el indicador KUMA80_ENA).

SD Card Filing System (SDCFS)

En lugar de implementar FAT (que seria demasiado grande para los bancos ROM de 2 KB disponibles), RFS utiliza un sistema de archivos disenado especificamente llamado SD Card Filing System (SDCFS). El diseno prioriza la simplicidad y una huella ROM reducida sobre la flexibilidad.

Estructura del directorio
Cada imagen de unidad SDCFS contiene un directorio plano de hasta 256 entradas. Cada entrada tiene exactamente 32 bytes, basada en el formato estandar de cabecera de cinta MZF:
Campo Bytes Descripcion
FLAG1 1 Bit 7 = 1: entrada valida. Bit 7 = 0: inactiva / eliminada.
FLAG2 1 Tipo de ejecucion MZF (0x01 = programa binario).
FILE NAME 17 Nombre de archivo MZF estandar de 17 caracteres (codificacion de caracteres Sharp).
START SECTOR 4 Primer sector dentro de esta imagen de unidad donde comienza el bloque de datos del archivo.
SIZE 2 Conteo real de bytes de los datos del archivo.
LOAD ADDR 2 Direccion RAM Z80 donde cargar los datos del archivo.
EXEC ADDR 2 Direccion de ejecucion automatica para archivos binarios (se salta a ella tras la carga).
RESERVED 3 No utilizado actualmente.
El directorio ocupa los primeros 8 KB de cada imagen de unidad (256 entradas x 32 bytes). Los datos de archivo siguen inmediatamente, comenzando en el limite de 32 bytes numero 256. A cada archivo se le asigna un bloque fijo de 64 KB — coincidiendo con el tamano maximo de bloque de cinta CMT — lo que mantiene la disposicion trivialmente simple y hace que la copia SD-a-cinta sea una transferencia byte a byte directa.

Disposicion de la tarjeta 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
────────────────────────────────────────────────────────────
No se escribe tabla de particiones. La imagen SDCFS comienza en el byte 0 de la tarjeta SD. Las imagenes de disco CP/M comienzan en el limite de 256 MB para dejar espacio a las 10 unidades RFS independientemente de lo llenas que esten.

Implementacion CP/M 2.2

Proceso de arranque
El arranque de CP/M en RFS ocurre en dos fases:
  1. Fase 1 — arranque AFI: el codigo ROM AFI (Auto Floppy Interface) original del MZ-80A en 0xF000 lee el primer sector del disquete o el bloque de arranque de la tarjeta SD. Comprueba los bytes marcadores 0x02 + "IPLPRO" en el byte 0 (la firma de disco arrancable CP/M del MZ-80A). Si los encuentra, pasa el control al cargador de segunda etapa encapsulado en ese sector.
  2. Fase 2 — carga de CCP+BDOS+CBIOS: el cargador de segunda etapa lee el CCP, el BDOS y el CBIOS desde el disco a la RAM comenzando en 0x9C00. Una vez cargados, se llama al punto de entrada de arranque en frio del CBIOS. El CBIOS configura el hardware (teclado, pantalla, unidades de disco) y pasa el control al CCP en 0x9C00.

Arquitectura del CBIOS
El BIOS personalizado (CBIOS) se divide en cinco modulos ROM para caber en el espacio de banco disponible:
Modulo Ubicacion ROM Contenido
cbios.asm MROM banco 2 (0xC000–0xCFFF) Puntos de entrada del CBIOS (los 17 vectores API), arranque en frio/en caliente, manejador de interrupciones, controlador de disco ROM, tablas de parametros de disco.
cbios_bank1.asm UROM banco 12 Audio (campana, melodia), rutinas de reloj en tiempo real, manejador de teclado con auto-repeticion.
cbios_bank2.asm UROM banco 13 Driver de pantalla (salida de caracteres, scroll, cursor), emulador de terminal ANSI (subconjunto VT52/VT100).
cbios_bank3.asm UROM banco 14 Driver de disco de tarjeta SD — lee y escribe sectores CP/M de 128 bytes desde las imagenes de unidad SDCFS que comienzan en el limite de 256 MB.
cbios_bank4.asm UROM banco 15 Controlador de disquete — soporte estandar de unidades de 8 pulgadas/5,25 pulgadas para discos CP/M fisicos.

API del CBIOS
El CBIOS CP/M implementa los 17 puntos de entrada API estandar de CP/M 2.2:
Punto de entrada Descripcion
BOOT Arranque en frio — inicializa todo el hardware, configura las tablas de parametros de disco, llama al CCP.
WBOOT Arranque en caliente — restaura el estado del hardware, recarga CCP+BDOS desde el disco, llama al CCP.
CONST Estado de consola — devuelve 0xFF si hay una tecla esperando, 0x00 si no.
CONIN Entrada de consola — espera una pulsacion de tecla y devuelve el codigo ASCII.
CONOUT Salida de consola — escribe un caracter en la pantalla.
LIST Salida de impresora — envia un caracter a la impresora conectada.
PUNCH Salida de perforadora/cinta — envia al dispositivo perforador de cinta.
READER Entrada de lector — lee desde el dispositivo lector de cinta.
HOME Busca la pista 0 en el disco seleccionado actualmente.
SELDSK Selecciona una unidad de disco (A:–G:) y devuelve la direccion del Disk Parameter Header.
SETTRK Establece la pista de disco para la siguiente operacion de lectura o escritura.
SETSEC Establece el sector de disco para la siguiente operacion de lectura o escritura.
SETDMA Establece la Disk Memory Address — donde se leeran o desde donde se escribiran los datos.
READ Lee un sector de 128 bytes del disco seleccionado al buffer DMA.
WRITE Escribe un sector de 128 bytes del buffer DMA al disco seleccionado.
LISTST Estado de impresora — devuelve el estado de disponibilidad del dispositivo de lista.
SECTRN Traduccion de sector — mapea numeros logicos de sector a posiciones fisicas usando la tabla de skew del disco.

Configuracion de unidades CP/M
Las unidades CP/M se crean dinamicamente durante el arranque en frio por el CBIOS, dependiendo de que controladores de disco esten disponibles. El mapeo de unidades estandar en un sistema RomDisk / picoZ80 totalmente equipado es:
Unidad CP/M Controlador Imagen
A: Tarjeta SD CPM_SYSTEM — programas del OS, Turbo Pascal, Hi-Soft C, Fortran 80, MS-BASIC 80
B: Tarjeta SD Pascal MTP v5.61, Turbo Pascal v3.00a, Pascal User Group disks
C: Tarjeta SD PLI, PLM 80, WordStar v3.0/v3.3/v4.0
D:–G: Tarjeta SD Discos de la coleccion Grant Searle CP/M C0–F9

Sistema de compilacion

RFS se compila en **Linux** (Debian/Ubuntu), **macOS** y **Windows** (mediante WSL2). El sistema de compilacion esta casi completamente contenido en el repositorio. La forma recomendada de compilar es el script de configuracion automatizada para su plataforma (vease Configuracion y compilacion automatizada mas abajo); los indicadores y pasos manuales que siguen son para usuarios avanzados y recompilaciones parciales.

Requisitos previos
Herramienta Proposito
Java JRE 8+ Ejecuta el ensamblador Z80 GLASS (tools/glass.jar). java debe estar en el PATH.
bash Todos los scripts de compilacion son scripts de shell bash.
perl Requerido por tools/mzftool.pl para la manipulacion de archivos MZF.
gcc / make Compila cpmtools desde el codigo fuente en la primera compilacion (automatico).
dd, cat, stat Utilidades estandar de Linux usadas por los scripts de empaquetado.
El ensamblador Z80 GLASS viene incluido en tools/glass.jar — no se requiere instalacion por separado.

Configuracion y compilacion automatizada (recomendado)
El script de configuracion automatizada para su plataforma instala los requisitos previos, clona el repositorio (si aun no se encuentra dentro de una copia), descarga las imagenes de contenido, escribe el archivo de entorno y ofrece ejecutar la primera compilacion — todo de forma interactiva, con valores predeterminados sensatos que puede aceptar pulsando Enter. Cada script es autocontenido: copie solo el unico archivo para su plataforma y ejecutelo.

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 PowerShell:

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

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

Windows 10 / 11 — setup_RFS_windows.ps1 (alternativa — 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 (se requiere un reinicio unico — reinicie, inicie Ubuntu una vez para crear su usuario de Linux, y luego vuelva a ejecutar), despues ejecuta setup_RFS.sh dentro de Ubuntu. Prefiera el script nativo a menos que quiera especificamente un entorno WSL.

Preguntas que hace la configuracion, y que hacer. Cada indicacion tiene un valor predeterminado seguro entre corchetes — la letra en mayuscula es el predeterminado, asi que pulsar Enter lo acepta.

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

Indicacion Predeterminado Que hacer
Continue anyway? [y/N] (si no se inicio como Administrador) No N, luego vuelva a abrir PowerShell como Administrador — instalar WSL requiere permisos de administrador.
Install WSL2 + Ubuntu now? [y/N] (si falta WSL/Ubuntu) No y — Windows instala WSL2 + Ubuntu, y luego le pide reiniciar; despues inicie Ubuntu una vez para crear su usuario y vuelva a ejecutar.
Repo URL [https://git.eaw.app/eaw/RFS.git] repo publico Enter para el repo publico, o pegue una URL diferente (p. ej. el repo de desarrollo privado).

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

Indicacion Predeterminado Que hacer
Install now? [Y/n] (si faltan herramientas) Si Enter — instala las herramientas que faltan mediante apt/dnf/pacman o Homebrew (macOS); puede pedir sudo. macOS tambien lanza las Xcode CLT y necesita Homebrew.
Repo URL [https://git.eaw.app/eaw/RFS.git]: (si aun no se esta en una copia) repo publico Enter para publico, o pegue la URL del repo privado. (Se omite en Windows — ya elegido.)
Install directory [~/RFS]: (al clonar) ~/RFS Enter para ~/RFS, o escriba una ruta.
Remove <dir> and re-clone …? [y/N] (si ese dir contiene un repo diferente) No y solo si esta seguro; de lo contrario N y elija otro directorio.
Download and install them now? [Y/n] (~110 MB de contenido) Si Enter para descargar el contenido MZF/disco/CP/M/BASIC (necesario para una compilacion completa); n solo si una copia hermana de SharpSoft ya lo proporciona.
Run the first build now (./build.sh -m …)? [Y/n] Si Enter para compilar de inmediato (verifica el entorno). La primera compilacion usa -m para procesar MZF → MZB/.

Tambien se le puede pedir su contrasena de sudo y sus credenciales de git (repo privado).

Tras la configuracion, recompile con ./build.sh -m (primera compilacion) y luego ./build.sh; en macOS ejecute antes source ./rfs_env.sh. build.sh compila todas las variantes de forma predeterminada; pase un nombre de variante (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k) para compilar una sola — seleccionar una variante configura los indicadores de compilacion automaticamente. Opciones: -m (procesar MZF), -s (omitir ensamblaje compartido), -c (limpiar), -v (detallado), -h (ayuda).

Avanzado: indicadores de compilacion (manual)
Para la mayoria de las compilaciones no necesita esto — build.sh <variant> los establece automaticamente. Para configurar un objetivo a mano, edite asm/include/rfs_definitions.asm y ponga exactamente un indicador de destino a 1 (todos los demas deben ser 0):
Indicador Destino
BUILD_ROMDISK EQU 1 Tarjeta RomDisk
BUILD_SFD700 EQU 1 Interfaz de disquete SFD-700
BUILD_PICOZ80 EQU 1 Tarjeta picoZ80
Indicadores opcionales de caracteristicas adicionales:
Indicador Predeterminado Descripcion
KUMA80_ENA 0 Ponga a 1 si esta instalada la mejora de 40/80 columnas Kuma.
VIDEOMODULE_ENA 0 Ponga a 1 si esta instalado el Modulo de Video a color de 40/80.
FUSIONX_ENA 0 Ponga a 1 cuando se ejecute en la tarjeta tranZPUter FusionX.
HW_SPI_ENA 1 SPI hardware (PCB RomDisk v2+). Dejelo en 1 para todas las tarjetas actuales.
SW_SPI_ENA 0 SPI por bit-bang software (RomDisk v1 mediante puerto paralelo).
ENADEBUG 0 Habilita la salida de depuracion en tiempo de ensamblado.

Pasos de compilacion manual y que hace build.sh
Si prefiere no usar el script de configuracion (o esta automatizando una compilacion CI), clone y compile directamente. Debe tener ya instalados los requisitos previos 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

# 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 ejecuta los siguientes pasos en orden:
  1. Compila cpmtools desde el codigo fuente (solo en la primera ejecucion) y lo agrega 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 y el CCP+BDOS de CP/M 2.2 en roms/*.rom.
  4. tools/assemble_roms.sh — ensambla todas las variantes del monitor y las aplicaciones MZF. Maneja las cuatro variantes de compilacion de MS-BASIC escribiendo un BUILD_VERSION EQU en include/msbasic_buildversion.asm antes de cada pasada.
  5. tools/make_roms.sh — empaqueta los binarios ROM y MZF en imagenes Flash ROM para cada destino.
  6. tools/make_cpmdisks.sh — construye imagenes de disco CP/M en formato RAW (para tarjeta SD) y en CPC Extended Disk Format (para emuladores de disquete).
  7. tools/make_sdcard.sh — combina 10 imagenes de unidad RFS y 7 imagenes de disco CP/M en la imagen final de la tarjeta SD.

Archivos de salida
Tras una compilacion exitosa, el directorio roms/ contiene:
Archivo Chip Flash Descripcion
MROM_ROMDISK_256.bin Flash Monitor ROM Monitor ROM para RomDisk: SA-1510, 80c SA-1510, CBIOS CP/M, utilidades mrom RFS, monitores 1Z-013A, tablas de opcodes ASM/DASM, IPL y cadenas de mensajes a lo largo de 16x4 KB de paginas.
MROM_PICOZ80_256.bin Flash Monitor ROM Monitor ROM para picoZ80 (el orden de bancos difiere del de RomDisk).
USER_ROM_256.bin Flash User ROM 1 Bancos RFS 0–11, bancos CBIOS CP/M 12–15, imagen CP/M 2.2, aplicaciones MZF empaquetadas.
USER_ROM_II_256.bin Flash User ROM 2 Aplicaciones MZF adicionales.
USER_ROM_III_256.bin Flash User ROM 3 Aplicaciones MZF adicionales.
SFD700_256.bin Flash SFD-700 ROMs AFI + firmware RFS + sistema de archivos ROM.
SHARP_MZ80A_RFS_IMAGE_0–9.img Tarjeta SD Imagenes de unidad RFS individuales (una por unidad 0–9).
SHARP_MZ80A_RFS_CPM_IMAGE_1.img Tarjeta SD Imagen combinada: 10 unidades RFS + 7 imagenes de disco CP/M. Escriba esta en la tarjeta SD.

Agregar aplicaciones a las unidades ROM
Los archivos de aplicacion en formato MZF deben convertirse a imagenes binarias con relleno de sector antes de su inclusion en las unidades ROM. Coloque los archivos MZF en el subdirectorio apropiado bajo MZF/ y luego ejecute: 
tools/processMZFfiles.sh
Esto produce imagenes con relleno de sector de 128 bytes y 256 bytes en MZB/. Para elegir que aplicaciones aparecen en cada unidad ROM, edite tools/make_roms.sh y ajuste las llamadas a 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"
Las aplicaciones se empaquetan en el orden listado, llenando primero la User ROM 1, luego la User ROM 2 y la 3. Coloque las aplicaciones de uso mas frecuente al principio de la lista.

Referencia de herramientas de compilacion
Herramienta Descripcion
build.sh Script de compilacion de nivel superior. Pase -m para reprocesar tambien los archivos MZF.
tools/assemble_rfs.sh Ensambla los modulos centrales de RFS.
tools/assemble_cpm.sh Ensambla el CBIOS y el kernel de CP/M 2.2.
tools/assemble_roms.sh Ensambla las variantes del monitor y los binarios de aplicacion MZF.
tools/make_roms.sh Empaqueta los binarios en imagenes Flash ROM.
tools/make_cpmdisks.sh Crea las imagenes de disco CP/M.
tools/make_sdcard.sh Combina las imagenes en la imagen final de la tarjeta SD.
tools/processMZFfiles.sh Convierte los archivos MZF a binarios con relleno de sector en MZB/.
tools/mzftool.pl Crea, extrae e inspecciona imagenes en formato MZF.
tools/sdtool Construye el directorio de la tarjeta SD RFS y lo rellena con archivos.
tools/nasconv Convierte imagenes de cassette NASCOM a formato cargable del MZ-80A, remapeando los tokens de MS-BASIC.
tools/glass.jar Ensamblador Z80 GLASS incluido (Java). Usado por todos los scripts de ensamblado.
tools/MZFD/MZFDTool Crea y gestiona imagenes de disquete raw para el FDC del MZ-700. Comandos: format, dir, add, extract, boot. Imagen predeterminada: MZ700.img.
tools/MZQD/MZQDTool Crea y gestiona imagenes QD para el sistema Quick Disk del MZ-700. Comandos: format, dir, add. Imagen predeterminada: MZ700.qd.
cpmtools/ Codigo fuente de cpmcp, cpmls, cpmrm, etc. Compilado en la primera compilacion.

Enlaces de referencia

Recurso Enlace
Pagina del proyecto RFS /es/sharpmz-upgrades-rfs/
Manual del usuario RFS /es/sharpmz-upgrades-rfs-usermanual/
Guia del desarrollador RFS /es/sharpmz-upgrades-rfs-developersguide/
Galeria RFS /es/sharpmz-upgrades-rfs-gallery/
Notas sobre CP/M en MZ-80A Incluidas en _pages/MZ80A_RFS_CPM_README.md
Guia tecnica SFD-700 mkII /sfd700-technicalguide/
Guia tecnica picoZ80 /es/picoz80-technicalguide/
Ensamblador Z80 GLASS Incluido en tools/glass.jar