A lo largo de los siguientes meses echaremos un vistazo al paquete
z88dk (http://z88dk.sourceforge.net)
y aprenderemos a realizar programas con él para nuestro Spectrum. Básicamente se
trata de un compilador cruzado de C, que nos permite realizar
nuestros programas en este lenguaje en nuestro ordenador de
sobremesa (PC con Windows o Linux, SPARC) y crear
un fichero que podrá ser ejecutado con un emulador y, mediante las herramientas
adecuadas, ser pasado a cinta
para ejecutarlo en nuestro Spectrum. Aunque en estos artículos nos centraremos
en la máquina objetivo de
esta publicación (el Sinclair ZX Spectrum), el z88dk permite desarrollar
aplicaciones
para una gran cantidad
de plataformas, entre ellas Sam Coupé, MSX1, Jupiter ACE, ZX81, y un gran número
de ordenadores basados en el procesador Z80.
El paquete incluye una serie de librerías que nos permitirán añadir
funcionalidades fácilmente a nuestros
programas, siendo las más interesantes las librerías gráficas, que nos capacitarán
incluso para programar algún
juego. El compilador de C incluido con z88dk no es más que un pequeño
compilador que acepta muchas de las
características de ANSI C y realiza optimizaciones básicas.
Por último, hemos de aclarar que el objetivo de esta serie de artículos no
es explicar la sintaxis o el
funcionamiento del lenguaje C; es más, al lector se le supondrán una serie
de conocimientos básicos sobre
el mismo. Como en el artículo de este número nos centraremos en
cómo instalar el paquete para distintas
plataformas, así como en conocer la forma de compilar y ejecutar los
ejemplos, el lector tendrá tiempo de
consultar cualquiera de los múltiples tutoriales sobre C existentes en la
red. En la Web del Programador (ver sección de enlaces)
se pueden encontrar multitud de enlaces relacionados con el tema.
INSTALACIÓN
Para descargarnos la última versión estable deberemos dirigirnos a la página
de descargas de z88dk (a partir
del enlace proporcionado en la página del paquete, ver sección de Links), donde
podremos obtener la versión de Linux. Los binarios para Windows se pueden
obtener en la página de Dennis
Grönign (el enlace también puede ser encontrado en la misma
página de z88dk).
INSTALACIÓN EN LINUX
El primer paso, una vez descargado el fichero z88dk-src-x.y.tar.gz
(donde x.y es la versión del paquete;
en el momento de redactar este artículo la última versión estable era la 1.5),
es desempaquetarlo en el directorio donde queramos tenerlo instalado:
tar -xvzf z88dk-src-x.y.tar.gz
Una vez hecho esto debemos compilar los distintos binarios y librerías que componen
z88dk:
cd z88dk
./build.sh
Para el uso de z88dk debemos darle un valor a una serie de variables de entorno.
Podemos hacer esto
creando un fichero setpath.sh (al que daremos permisos
de ejecución con
chmod a+x setpath.sh) con el
siguiente contenido:
export Z88DK="{z88dk}/z88dk"
export PATH="$PATH:$Z88DK/bin"
export Z80_OZFILES="$Z88DK/lib/"
export ZCCCFG="$Z88DK/lib/config/"
donde {z88dk} es el directorio donde hemos desempaquetado el tar.gz.
Cada vez que vayamos a utilizar z88dk, deberemos ejecutar este fichero mediante
el siguiente comando:
source setpath.sh
Con esto hacemos que las variables de entorno queden definidas para el shell actual.
Una herramienta de la que haremos uso en la creación de nuestros programas es
bin2tap. Este programa transforma
los binarios producidos por el compilador en archivos TAP que pueden ser
ejecutados en un emulador. Afortunadamete,
este programa viene incluido con z88dk. Desgraciadamente, se incluye sin
compilar, y además, tampoco se
compila al ejecutar el ./build.sh anteriormente indicado.
Para construirlo, nos desplazamos al directorio
$Z88DK/support/zx/, y ejecutamos:
cc -o bin2tap bin2tap.c
De esa forma crearemos el ejecutable del programa. Para poder utilizarlo
cómodamente, lo copiamos al directorio bin:
mv $Z88DK/support/zx/bin2tap $Z88DK/bin/
COMPILAR Y EJECUTAR EN LINUX
Una vez instalado el paquete, y preparado nuestro sistema, pasamos a explicar
cómo podemos compilar
nuestros programas, y ejecutarlos en cualquier emulador. Para ello nos
basamos en los ejemplos situados
en el directorio $Z88DK/examples/spectrum.
En el directorio anterior encontramos una serie de archivos .c, conteniendo programas
en C que utilizan
las librerías de z88dk. En el archivo README tenemos una
descripción de qué hace cada uno de ellos. Vamos
a compilar y a probar el gfx.c, que incorpora una
serie de efectos gráficos y que a priori
puede parecer el más espectacular, visualmente hablando. Para ello, según
el archivo README, podemos ejecutar:
zcc +zx -o gfx.bin gfx.c -lndos
A continuación hacemos una breve descripción de la sintaxis:
- Justo después del comando zcc especificamos la máquina destino, es decir,
la máquina para la cual se
va a producir el binario. En nuestro caso deseamos crear un binario para el
ZX Spectrum, así que usamos
el modificador +zx (los modificadores correspondientes a cada una de las máquinas
soportadas los podemos
encontrar en $Z88DK/doc/compile.txt).
- Con el parámetro -o especificamos el nombre del archivo binario resultante
(en nuestro caso, gfx.bin).
- Después indicamos el nombre del fichero fuente.
- Por último, con -lndos hacemos que se enlace con la librería ndos
(en próximas entregas entraremos en detalle
sobre las librerías más útiles y las funcionalidades que ofrecen). Las
librerías se encuentran en $Z88DK/libsrc/.
Como se puede observar, la sintaxis es muy parecida al compilador gcc de
Linux, así que si ya estamos
acostumbrados a programar en C en esta plataforma, no deberíamos tener ningún
problema. El archivo resultante,
gfx.bin, es un archivo binario (no entenderemos su contenido si lo editamos
con un editor de texto). Hay que
tener en cuenta que zcc no es el compilador en sí, sino que es un frontend que
se encarga de ejecutar el
compilador y el ensamblador/enlazador (todas estas aplicaciones se pueden
encontrar en el directorio $Z88DK/bin/).
Este archivo binario todavía no puede ser ejecutado en ningún emulador,
primero debemos pasarlo a un formato
adecuado. Para ello podemos hacer uso de la aplicación bin2tap, que compilamos
en el apartado anterior:
bin2tap gfx.bin gfx.tap
¡Y ya podemos probar el programa en nuestro emulador favorito!
|
Efecto gráfico programado en C para el Spectrum
por medio de z88dk
|
INSTALACIÓN EN WINDOWS (gracias a la colaboración de MIGUEL)
Esta instalación ha sido realizada y probada sobre un PC con Windows 98 Second Edition.
Se intentó realizar en un
sistema con Windows XP y los ejecutables contenidos en el directorio bin daban
el error "xxxxxxx.exe
no es un archivo win32 válido" (Esto puede ser debido más al PC en el que el
autor tiene instalado el
sistema operativo que a problemas de incompatibilidad entre el propio z88dk y Windows
XP).
El primer paso que tenemos que llevar a cabo es descargarnos el archivo
z88dk-win32-x.y.zip (donde x.y
indica la versión de z88dk) que podemos
encontrar en la web del proyecto. Una vez descargado, descomprimimos el
zip en el directorio c:\z88dk, que va a ser el directorio
que
usemos por defecto para explicar la
instalación, y que podemos cambiar a uno que nos agrade más cambiando la ruta
en todas las explicaciones que se dan a continuación.
|
Un ejemplo de programa donde se hace uso de
lectura del teclado
|
Lo siguiente es añadir la ruta de los ejecutables y las librerías al archivo
autoexec.bat. Para esto
tenemos dos opciones:
-
Añadir manualmente la ruta, editando el archivo autoexec.bat.
Para hacerlo simplemente editamos el archivo autoexec.bat, situado en
c:/, con el Bloc de Notas de Windows,
o, desde una ventana de MS-DOS con "edit autoexec.bat"
y le añadimos las siguientes líneas:
SET Z80_OZFILES=C:\z88dk\Lib\
SET ZCCCFG=C:\z88dk\Lib\Config\
SET PATH=%PATH%;C:\z88dk\Bin
-
Al descomprimir el zip que contiene los archivos del z88dk, hay un archivo
llamado
SETZ88-W95.inf,
situamos el puntero del ratón encima de él, pulsamos el botón derecho y hacemos
clic en instalar, con
lo cual se añade la ruta automáticamente al archivo autoexec.bat.
Una vez realizada cualquiera de las dos opciones anteriores, reiniciamos el
PC para que se actualicen las rutas que acabamos de introducir.
|
Otro programa de ejemplo incluido con z88dk |
COMPILAR Y EJECUTAR EN WINDOWS
Cuando programamos con z88dk, escribimos el código en lenguaje C en archivos de
texto plano, con nuestro editor preferido, puede ser el Bloc de Notas que trae
Windows perfectamente. Estos archivos se suelen nombrar como
programa.c.
Para mostrar brevemente como creamos un archivo interpretable por un
emulador de ZX Spectrum, o cargarlos
en un ordenador real, vamos a usar uno de los ejemplos que vienen con el z88dk.
-
Lo primero que hacemos es abrir una ventana de MS-DOS y, después, desde ésta nos
situamos en la carpeta donde están los ejemplos para el ZX Spectrum:
CD..
Para colocarnos en el directorio raíz de C:
CD z88dk\examples\spectrum
Con eso nos situamos en la carpeta donde están los ejemplos para ZX Spectrum
En esta carpeta encontraremos varios ficheros, concretamente vamos a usar el
gfx.c que nos crea unos efectos gráficos en la
pantalla del emulador/Spectrum.
-
Ahora tenemos que compilar el programa, para ello vamos a usar el ejecutable
ZCC.EXE, que está ubicado
en la carpeta BIN, pero no tenemos que entrar en
ella para nada, ya que anteriormente añadimos el path.
Vamos a compilar, para ello tecleamos en la ventana de MS-DOS:
zcc +zx -o gfx.bin gfx.c -lndos
Al ejecutarlo se crea un archivo .bin en el que
tendremos nuestro programa y que necesitaremos pasar a un
formato que pueda comprender el emulador, o el programa que usemos para pasarlo
a cinta y cargarlo con el ZX Spectrum.
-
Para pasar el archivo .BIN a .TAP, tenemos un programa llamado
BIN2TAP.EXE que viene incluido en el
kit del z88dk y situado en el directorio \support\zx.
Su uso es muy sencillo, tenemos que tener en la misma carpeta el archivo
.BIN y el programa BIN2TAP.exe,
también podemos incluir la ruta del bin2tap en el path, eso lo dejamos a nuestra
elección.
Ejecutamos: BIN2TAP gfx.bin gfx.tap
Y ya tenemos nuestro programa preparado para cargarlo en nuestro emulador preferido.
NOTA: en el caso de disponer de una plataforma Windows se recomienda leer
también de forma detenida
el apartado de compilación y ejecución en Linux donde se explican una serie
de conceptos importantes sobre el proceso.