Generar una imagen de cassette (CDT)

Table of contents
  1. Cargador en BASIC
  2. Convertir a ASCII
  3. Generar imagen de cassette
  4. Cargar la imagen CDT en RVM

Cargador en BASIC

Utilizaremos un programa escrito en BASIC para cargar el binario en memoria y ejecutarlo. Crea un archivo llamado src/loader.bas con el siguiente contenido:

10 MEMORY &3fff
20 MODE 1: BORDER 0
30 LOAD "!hola.bin",&4000
40 CALL &4000

Veamos cada línea:

  • Línea 10: MEMORY &3fff reserva la memoria por debajo de &4000 para evitar conflictos. Más adelante veremos el mapa de memoria del CPC y la razón de esta elección.
  • Línea 20: MODE 1 y BORDER 0 configuran el modo gráfico por defecto (opcional).
  • Línea 30: LOAD "!hola.bin",&4000 carga el binario generado por RASM en la dirección &4000.
  • Línea 40: CALL &4000 ejecuta el código cargado, que imprimirá “HOLA MUNDO CPC!” en pantalla.

Convertir a ASCII

El siguiente paso es convertir el archivo BASIC a formato ASCII. Para esto yo utilizo una pequeña utilidad que he escrito en Python, de la que ya hablamos en la sección Conversión a ASCII: cpcascii.

Puedes convertir el archivo BASIC a ASCII ejecutando (ajusta las rutas según tu estructura de proyecto):

tools/cpcascii/cpcascii --amsdos -o output/loader.bas src/loader.bas

Verás algo similar a esto:

==================================================
CONVERSION SUMMARY
==================================================
Input file:           src/loader.bas
  Total lines:        5
Output file:          output/loader.bas
  Converted lines:    4
  File size:          276 bytes
  AMSDOS end char:    yes
==================================================

Con --amsdos indicamos que se incluya el carácter de final de archivo necesario para que el archivo sea reconocido por el sistema AMSDOS.

En output/loader.bas tendrás el archivo convertido listo para ser incluido en la imagen de cassette.

Generar imagen de cassette

Para generar la imagen de cassette utilizaremos la herramienta 2cdt, de la que también hablamos previamente, en este caso en la sección Imágenes de cinta: 2cdt.

Primero crearemos una imagen de cinta vacía y añadiremos el cargador BASIC:

tools/2cdt -n -s 0 -F 22 -r LOADER output/loader.bas hola.cdt

Yendo por partes:

  • -n indica que se cree una nueva imagen de cinta en blanco.
  • -s 0 indica la velocidad de escritura, en este caso 1000 baudios (0 = 1000 baudios, 1 = 2000 baudios).
  • -F 22 indica el tipo de fichero a añadir, en este caso usamos 22 para ASCII.
  • -r LOADER indica el nombre del archivo dentro de la imagen de cinta.
  • output/loader.bas es el archivo que queremos añadir a la imagen de cinta (el que generamos en el apartado anterior).
  • hola.cdt es el nombre de la imagen de cinta que se generará.

La salida del comando debería ser algo como esto:

Baud rate set to: 1000
Type set to: 22
Filename: LOADER
Will write file output/loader.bas to hola.cdt
File length: 276
File output/loader.bas potentially has a header
File output/loader.bas does not have a header
Output file written

Y obtendremos el archivo hola.cdt listo para ser cargado en RVM o grabado en una cinta real. Pero aún nos falta añadir el binario generado por RASM a la imagen de cinta, de otro modo el comando LOAD del cargador no encontraría nada a continuación. Lo haremos con el siguiente comando:

tools/2cdt -s 0 -r hola.bin -L 0x4000 bin/hola.bin hola.cdt

Con respecto al comando anterior, la única opción desconocida es -L 0x4000, que indica la dirección de carga del binario en memoria, que en este caso es &4000 (la misma dirección que aparece en la instrucción org $4000 al principio del código; también la misma en la que el cargador BASIC carga el programa y desde la que lo ejecuta).

Veremos una salida similar a esta:

Baud rate set to: 1000
Filename: HOLA.BIN
Load address set to: &4000
Will write file bin/hola.bin to hola.cdt
File length: 30
File bin/hola.bin is to short to have a header
Output file written

Ahora ya sí, la imagen de cinta hola.cdt contiene tanto el cargador BASIC como el binario del programa, y está lista para ser utilizada en RVM.

Cargar la imagen CDT en RVM

Podemos hacerlo manualmente desde la interfaz de RVM o utilizar el script que vimos en la sección Emulador de Amstrad CPC: Retro Virtual Machine para lanzar directamente el emulador con la imagen de cinta cargada. En este último caso, sería tan sencillo como ejecutar la siguiente orden (ajustando las rutas según tu estructura de proyecto):

tools/rvm.sh hola.cdt

Tras ejecutar el comando, se abrirá el emulador con la cinta en el reproductor, comenzará la carga del programa en modo warp y, una vez cargado, se ejecutará automáticamente el programa BASIC que a su vez cargará el binario y lo ejecutará, mostrándote el mensaje “HOLA MUNDO CPC!” en pantalla.

Captura de pantalla del emulador con el mensaje "HOLA MUNDO CPC!" en pantalla

A diferencia de cuando ejecutamos directamente el binario en RVM, en este caso vemos que se ha limpiado la pantalla y el borde ha cambiado de color. Ambas cosas las hace el cargador BASIC en la línea 20, antes de cargar y ejecutar el binario.