Categorías
Programación

Hola mundo en .rom, .bin .cas, .wav y .com con ensamblador sdasz80 en c con sdcc

Introducción

Sdcc nos va permitir escribir código en c o en ensamblador (con sdasz80) y generará una serie de archivos.

Tendremos que crear un make (mira el punto 7) porque vamos a necesitar 6 pasos y no queremos escribir mucho.

Puedes descargarte el código completo pinchando aquí.

En resumen haremos esto:

Contenido

Introducción.

1.Instalando SDCC.

2.Copiar y pegar el código para estudiarlo.

3.Compilando a z80 sdcc -mz80 –no-std-crt0 –code-loc 0x4010 –data-loc 0xc000 hola.c.

4.Creando nuestro binario con hex2bin -e bin nombre_archivo.ihx.

5.Añadiendo la cabecera para que sepa el MSX que es un rom..

6.Rellenando los 32768 bytes de la rom..

7.Creando el Make para que haga todo el proceso anterior automáticamente.

8.Mejorando nuestro make.

8.1.Haciendo que se abra solo el openMSX.

8.2 Creando una carpeta para almacenar nuestros recursos.

8.3 Creando el archivo de arranque o CRT

8.3.1 Poner la cabecera

8.3.1.1 CRT para rom

8.3.1.2 CRT para bin

8.3.1.2.1 Convertir .bin a .cas

8.3.1.2.2 Convertir .cas a .wav

8.3.1.3 CRT para .com

8.3.3 Decirle al z80 que disposición de memoria tiene

1.Instalando SDCC

Vamos a la web https://sourceforge.net/projects/sdcc/ o pinchamos aquí para descargar para instalarnos el compilador de c para z80, al final de la instalación te dirá que va a incluir el path de sdcc en tu sistema, lo dejamos marcado:

Lo probamos abriendo un terminal y poniendo sdcc

2.Copiar y pegar el código para estudiarlo

1.Creamos una carpeta con el nombre hola mundo y dentro un archivo con el nombre de hola.c y le pegamos este código:

#include 
#include 


void main() 
{
    //etiqueta de c que indica el cominedo de un bloque con lenguaje ensamblador
  __asm
    ld hl, #string ; en sdcc en los valores inmediatos hay que poner siempre la amohadilla
    call Print  ; Llama al método Print
    jr .        ; el punto (.) quiere decir la posición de la ram actual que se está ejecutando, es quiere decir que es un bucle infinito

    Print:
    ld  a,(hl)          ; Lee el 1 byte de la dirección de la memoria indicada y lo almacena en el registro a del z80.
    cp #0               ; Actualiza la bandera z del registro F del z80 y la pone un 1 si encuentra un 0.
    ret z               ; Devuelve el cotrol al Main si la bandera z del registro F del z80 es 0
    call #0x00A2        ; En sdcc los valores hexadecimales se expresan como en c, con 0x
                        ; Llama a la subrutina 00A2h de la Bios la cual imprime el caracter almacenado en el registro a del z80
    inc hl              ; incrementa el puntero de los registros hl para que señale al siguiente byte
    jr Print            ; Llama al métdo print para que lo vuelva a ejecutar
    
    string: .ascii "Hola mundo en .rom con ensamblador sdas en c con sdcc"
            .db 0  
  __endasm; //Etiqueta de c que indica el final de un bloque con lenguaje ensamblador
 
}

3.Compilando a z80 sdcc -mz80 –no-std-crt0 –code-loc 0x4010 –data-loc 0xc000 hola.c

Ponemos: sdcc -mz80 –no-std-crt0 –code-loc 0x4010 –data-loc 0xc000 hola.c

-mz80 :para indicarle el procesador

–no-std-crt0 : es para indicar que sdcc incluya el crt suyo de arranque, el tema de crt es complejo y lo veremos más adelante

–code-loc 0x4010 :para indicarle la dirección de la ram en la que queremos iniciar nuestro código

–data-loc  0xc000 :la localización en la ram de las variables que es las rom se pone en 0xc000

hola.c :es el archivo que queremos pasar a z80

Esto nos genera los archivos:

hola.asm que es el código en ensamblador

hola.ihx que es el código hexadecimal generado para intel, es el más importante

hola.map las direcciones y los tamaños donde están nuestras instrucciones

hola.rel es el código objeto o máquina

hola.sym es para temas de depuración

4.Creando nuestro binario con hex2bin -e bin nombre_archivo.ihx

Nuestro MSX solo lee archivos binarios (o secuencias de bytes) y el código que nos genera el sdcc es intel hexadecimal.

Una vez obtenidos los archivos hay que pasar el prueba.ihx a binario, esto se hace con el programa hex2bin (pincha aquí para bajarlo) tienes que copiarlo y pegarlo en el directorio de tu proyecto (1):

Después ponemos en el cmd (2):

hex2bin -e bin hola.ihx

Después podremos ver que se ha generado el archivo hola.bin (3)

5.Añadiendo la cabecera para que sepa el MSX que es un rom

Una vez obtenido el binario o hola.bin:

1.Descargamos “rom_header.bin”(descárgatelo pinchando aquí), este archivo tiene la información necesaria de la cabecera de un rom.

2.Pon este comando en el terminal

copy /b rom_header.bin + /b hola.bin /b hola.rom

Para unirlo con el hola.bin anterior

3.Se creará un nuevo archivo el hola.rom

6.Rellenando los 32768 bytes de la rom

Nos bajamos el programa fillfile.es (pinchando aquí) y lo pegamos en nuestro directorio ya que nuestra rom necesita que se le rellenen los bytes hasta 32768 (o #0x8000) o 32Kb:

Ahora ya podemos probar nuestro rom en openMSX:

7.Creando el Make para que haga todo el proceso anterior automáticamente

Creamos un nuevo archivo y lo llamamos make.bat (estos archivos son los ejecutables del cmd de windows), dentro ponemos:

@echo off 
rem con echo off quitamos los mensajes de nuestro código que puedan salir por la consola
rem Ponemos el nombre del programa al comienzo por si queremos cambiarlo
Set nombrePrograma=hola
rem echo . son solo saltos de línea
echo .
echo ------------------------------------------
echo     Compilando el programa "%nombrePrograma%"
echo       author: MSX claro pijo 2020
echo ------------------------------------------
echo .
rem 1.compilamos nuestro programa c con el ensamblador embebido
sdcc -mz80 --no-std-crt0 --code-loc 0x4010 --data-loc 0xC000 %nombrePrograma%.c 

rem 2. Creamos el binario para MSX con el programa hex2bin
hex2bin -e bin %nombrePrograma%.ihx 

rem 3.Añadimos la cabecera para el MSX
copy /b rom_header.bin + /b resources\%nombrePrograma%.bin /b %nombrePrograma%.rom

rem 4.Lo rellenamos de bytes hasta 32768 (32Kb)
fillfile %nombrePrograma%.rom 32768 


Al escribir make.bat en el terminal, haremos los pasos anteriores automáticamente:

Vamos a cambiar el texto y borramos todos los hola.* menos el hola.c y haremos el proceso con el make:

8.Mejorando nuestro make

1.Haremos que el openMSX se abra solo.

2.Crearemos una carpeta para almacenar nuestros recursos.

8.1.Haciendo que se abra solo el openMSX

OpenMSX puede ejecutar scripts para eso tan solo tenemos que crear un archivo txt y ponerle la configuración que queramos, vamos a crear un directorio llamado openMSX y dentro creamos el archivo emul_start_config.txt, dentro ponemos este texto:

machine Philips_NMS_8255 
ext msxdos2 
ext gfx9000 
bind F12 cycle videosource
plug joyporta mouse 
plug printerport simpl 
cart hola.rom



Ahora vamos al make y ponemos al final del archivo:

rem 5.Despues de crear el archivo emul_start_config.txt abrimos el openMSX
rem en los archivos .bat se crean las constantes con set
rem Esta es mi ruta donde tengo mi openMSX, si lo has instalado lo tendrás en C:\Program Files\openMSX\openmsx.exe
Set rutaOpenMSX=C:\Users\Casa\Desktop\openmsx-0.15.0-windows-vc-x64-bin\openmsx.exe
Set rutaScriptOpenMSX=openMSX\emul_start_config.txt
Set procesoOpenMSX=openmsx.exe
rem tasklist muestra una lista de procesos que se está ejecutando en el equipo, por favor pon tasklist /? en el cmd
rem find busca una cadena ed texto en uno o más archivos, por favor pon find /? en el cmd
tasklist | find /i "%procesoOpenMSX%">nul  && (echo %procesoOpenMSX% openMSX ya esta arrancado) || start %rutaOpenMSX% -script %rutaScriptOpenMSX% 



8.2Creando una carpeta para almacenar nuestros recursos

Abrimos en make.bat, lo borramos todo (digo eso porque tendremos que poner la carpeta resources a muchos archivos) y le ponemos esto:

@echo off 
rem con echo off quitamos los mensajes de nuestro código que puedan salir por la consola
rem Ponemos el nombre del programa al comienzo por si queremos cambiarlo
Set nombrePrograma=hola
rem echo . son solo saltos de línea
echo .
echo ------------------------------------------
echo     Compilando el programa "%nombrePrograma%"
echo       author: MSX claro pijo 2020
echo ------------------------------------------
echo .
rem 1.compilamos nuestro programa c con el ensamblador embebido
sdcc -mz80 --no-std-crt0 --code-loc 0x4010 --data-loc 0xC000 %nombrePrograma%.c 

rem 2. Creamos el binario para MSX con el programa hex2bin
hex2bin -e bin %nombrePrograma%.ihx 

rem 3.Añadimos la cabecera para el MSX
copy /b rom_header.bin + /b resources\%nombrePrograma%.bin /b %nombrePrograma%.rom

rem 4.Lo rellenamos de bytes hasta 32768 (32Kb)
fillfile %nombrePrograma%.rom 32768 

rem 5.Despues de crear el archivo emul_start_config.txt abrimos el openMSX
rem en los archivos .bat se crean las constantes con set
rem Esta es mi ruta donde tengo mi openMSX, si lo has instalado lo tendrás en C:\Program Files\openMSX\openmsx.exe
Set rutaOpenMSX=C:\Users\Casa\Desktop\openmsx-0.15.0-windows-vc-x64-bin\openmsx.exe
Set rutaScriptOpenMSX=openMSX\emul_start_config.txt
Set procesoOpenMSX=openmsx.exe
rem tasklist muestra una lista de procesos que se está ejecutando en el equipo, por favor pon tasklist /? en el cmd
rem find busca una cadena ed texto en uno o más archivos, por favor pon find /? en el cmd
tasklist | find /i "%procesoOpenMSX%">nul  && (echo %procesoOpenMSX% openMSX ya esta arrancado) || start %rutaOpenMSX% -script %rutaScriptOpenMSX% 

rem 6.creando una carpeta para mover nuestros recursos
If not exist .\resources md .\resources
rem le ponemos el nombre a nuestro programa

rem lo movemos a resources, por favor pon move /? o @move /? en el cmd
move %nombrePrograma%.asm ./resources
move %nombrePrograma%.bin ./resources
move %nombrePrograma%.ihx ./resources
move %nombrePrograma%.lk ./resources
move %nombrePrograma%.lst ./resources
move %nombrePrograma%.map ./resources
move %nombrePrograma%.noi ./resources
move %nombrePrograma%.rel ./resources
move %nombrePrograma%.sym ./resources





Recuerda tener el openMSX cerrado:

8.3 Creando el archivo de arranque o CRT

CRT son las siglas de common runTime y es el primer código que se ejecutará y ha de prepararlo todo para que funcione correctamente el entorno requerido. Nuestro CRT tiene que hacer varias cosas:

1.Poner la cabecera.

2.Ir al main o entrada de código.

Otros pasos son los siguientes

3.Decirle al z80 que disposición de memoria tiene.

4.Ajustar el puntero de pila

5.Poner a cero la memoria

6. Ejecutar código del GSINIT y GSFINAL inicio

7. Copiar los datos correspondientes a las variables globales que se inicializan de INTIALIZER a INITALIZED

8. Inicializar algunos periféricos

8.3.1 Poner la cabecera

8.3.3.1 CRT rom

Descárgate el proyecto completo pinchando aquí.

Cuando tienes metido un cartucho y encienciendes el msx, la bios se busca la vida intentando identificar un de estas configuraciones de la RAM:

Lo normal el que volquemos las instrucciones del .rom en la zon #4000 y en #c000 pongamos nuestras variables.

1.Creamos el archivo crt0_rom

; SDCC C MSX ROM startup (crt) 
; Comenzando en 0x4010
; Pon el sdcc: --code-loc 0x4020 --data-loc 0xC000
; Declaramos global el _main del archivo main.c para poder utilizarlo
.module crt0
.globl	_main

.area _HEADER (ABS)
	.org 0x4000
  
	.db  0x41
	.db  0x42
	.dw  init
	.dw  0x0000
	.dw  0x0000
	.dw  0x0000
	.dw  0x0000
	.dw  0x0000
	.dw  0x0000
	
init:
  di
	ld   SP,(#0xFC4A) 
	ei
	
  call _main   
	RST  0 ;CHKRAM

.area   _DATA
.area   _GSINIT
.area   _GSFINAL

2.Cambiamos el archivo openMSX/emul_start_config.txt:

Ponemos esto:

machine Philips_NMS_8255 
ext msxdos2 
ext gfx9000 
bind F12 cycle videosource
plug joyporta mouse 
plug printerport simpl 
cart main.rom




3.El make.bat debe quedar así

@echo off 
Set nombrePrograma=main
Set crt=crt0_rom
echo ------------------------------------------
echo     Compilando el programa "%nombrePrograma%"
echo       author: MSX claro pijo 2020
echo ------------------------------------------

rem 1.Pasamos el crt.asm a crt.rel
sdasz80 -l -o %crt%.s
rem 2.compilamos nuestro programa c con el ensamblador embebido
sdcc -mz80 --no-std-crt0 --code-loc 0x4020 --data-loc 0xC000 %crt%.rel %nombrePrograma%.c 
rem 3. Creamos el binario para MSX con el programa hex2bin
hex2bin -e rom %nombrePrograma%.ihx 

rem 4.Lo rellenamos de bytes hasta 32768 (32Kb)
fillfile %nombrePrograma%.rom 32768 

rem 5.Despues de crear el archivo emul_start_config.txt abrimos el openMSX
rem en los archivos .bat se crean las constantes con set
rem Esta es mi ruta donde tengo mi openMSX, si lo has instalado lo tendrás en C:\Program Files\openMSX\openmsx.exe
Set rutaOpenMSX=C:\Users\Casa\Desktop\openmsx-0.15.0-windows-vc-x64-bin\openmsx.exe
Set rutaScriptOpenMSX=openMSX\emul_start_config.txt
Set procesoOpenMSX=openmsx.exe
rem tasklist muestra una lista de procesos que se está ejecutando en el equipo, por favor pon tasklist /? en el cmd
rem find busca una cadena ed texto en uno o más archivos, por favor pon find /? en el cmd
tasklist | find /i "%procesoOpenMSX%">nul  && ( echo %procesoOpenMSX% openMSX ya esta arrancado) || start %rutaOpenMSX% -script %rutaScriptOpenMSX% 
rem start %rutaOpenMSX% -script %rutaScriptOpenMSX% 

rem 6.creando una carpeta para mover nuestros recursos
If not exist .\resources md .\resources
rem le ponemos el nombre a nuestro programa

rem lo movemos a resources, por favor pon move /? o @move /? en el cmd
move %nombrePrograma%.asm ./resources
move %nombrePrograma%.bin ./resources
move %nombrePrograma%.ihx ./resources
move %nombrePrograma%.lk ./resources
move %nombrePrograma%.lst ./resources
move %nombrePrograma%.map ./resources
move %nombrePrograma%.noi ./resources
move %nombrePrograma%.rel ./resources
move %nombrePrograma%.sym ./resources


4.Compilamos:

Abrimos un cmd y ponemos make.bat:

8.3.1.2 CRT para bin

Podemos descargarnos el proyecto completo pinchando aquí.

Es importante entender que cuando enciendes el msx el ve esta distribución de la RAM:

Utilizaremos la zona #8000 y #c0000 para cargar nuestros bin.

1.Creamos el crt0_bin:

No le hagas mucho caso a las variables que necesita el linkador que hay dentro del sdasz80 para relacionar los archivos y construir todo el andamiaje con archivos.c, la más importante es _GSINIT:

.module ctr0
.globl  _main
;; Ordenando los segmentos del linker.
.area _HOME
.area _CODE
.area _GSINIT
.area _GSFINAL
.area _INITIALIZER

.area _DATA
.area _INITIALIZED
.area _BSEG
.area _BSS
.area _HEAP

.area _HEADER (ABS)
.org 0x8000

.db     0xfe
.dw     init
.dw     _end
.dw     init

init:
    call    _main

.area   _GSINIT
_end:
    ret




2.Cambiamos el archivo openMSX/emul_start_config.txt:

machine Philips_NMS_8255 
ext msxdos2 
ext gfx9000 
bind F12 cycle videosource
plug joyporta mouse 
plug printerport simpl 
diska .


3.El make.bat debe quedar así

@echo off 
Set nombrePrograma=main
Set crt=crt0_bin

echo ------------------------------------------
echo     Compilando el programa "%nombrePrograma%"
echo       author: MSX claro pijo 2020
echo ------------------------------------------

rem 1.Pasamos el crt.asm a crt.rel
sdasz80 -l -o %crt%.s

rem 2.compilamos nuestro programa c con el ensamblador embebido
sdcc -mz80 --no-std-crt0 --data-loc 0xc000 --code-loc 0x8020 %crt%.rel %nombrePrograma%.c 

rem 3. Creamos el binario para MSX con el programa hex2bin
hex2bin -e bin %nombrePrograma%.ihx 

rem 4.Despues de crear el archivo emul_start_config.txt abrimos el openMSX
rem en los archivos .bat se crean las constantes con set
rem Esta es mi ruta donde tengo mi openMSX, si lo has instalado lo tendrás en C:\Program Files\openMSX\openmsx.exe
Set rutaOpenMSX=C:\Users\Casa\Desktop\openmsx-0.15.0-windows-vc-x64-bin\openmsx.exe
Set rutaScriptOpenMSX=openMSX\emul_start_config.txt
Set procesoOpenMSX=openmsx.exe
rem tasklist muestra una lista de procesos que se está ejecutando en el equipo, por favor pon tasklist /? en el cmd
rem find busca una cadena ed texto en uno o más archivos, por favor pon find /? en el cmd
tasklist | find /i "%procesoOpenMSX%">nul  && (echo %procesoOpenMSX% openMSX ya esta arrancado) || start %rutaOpenMSX% -script %rutaScriptOpenMSX% 

rem 5.creando una carpeta para mover nuestros recursos
If not exist .\resources md .\resources
rem le ponemos el nombre a nuestro programa

rem lo movemos a resources, por favor pon move /? o @move /? en el cmd
move %nombrePrograma%.asm ./resources
rem move %nombrePrograma%.bin ./resources
move %nombrePrograma%.ihx ./resources
move %nombrePrograma%.lk ./resources
move %nombrePrograma%.lst ./resources
move %nombrePrograma%.map ./resources
move %nombrePrograma%.noi ./resources
move %nombrePrograma%.rel ./resources
move %nombrePrograma%.sym ./resources


4.Compilamos y escribimos bload”main.bin”,r:

8.3.1.2.1 Convertir .bin a .cas

Para poder convertir un .bin a cas necesitamos la utilidad mcp, des. También puedes mirar el artículo http://msx.tipolisto.es/como-convertir-cas-en-wav-con-mcp-msx-caspackage/

1.Nos descargamos MCP y lo ponemos en la raíz de nuestro proyecto:

2.Tenemos que crear un archivo cargador, lo llamaremos «cargador.asc», dentro le pondremos los comandos en basic para la carga de la cinta:


10 CLS:BLOAD"CAS:",R

3.Ahora creamos nuestro fichero .cas añadiendo el cargador.asc y el .bin, ponemos

mcp -a main.cas cargador.asc main.bin

Vamos a probarlo:

Recuerda poner esto en el make.bat

8.3.1.2.2 Convertir .cas a .wav

Tenemos que tener el mcp en la raiz de nuestro proyecto y escribir en un cmd


mcp -e main.cas main.wav

Ahora escribimos en el basic bload»cas:»,r

8.3.1.3 CRT para .com

Puedes descargarte el código completo pinchando aquí.

Para los .com al crear un reproductor de discos e incluir dentro los archivos COMMAND2.COM (el interprete)y MSXDOS2.SYS (las rutinas que enlazan con las bios), el msx lo detecta e inicializa la confiduración de la RAM solo,  tan solo es necesario inicializar las variables –code-loc 0x100 –data-loc 0x0, así que podemos obviar el crt0, pero en este ejemplo incluimos un crt.

Debes de recordar que el MSX-DOS utiliza sus propias rutinas, por lo tanto las llamadas a las rutinas de la bios se inutilizan. Este sistema operativo venía con alguna utilidades más en las roms de algunos cartuchos.

Es importante saber la distrubución que hace el msx en el modo MS-DOS:

Los programas en .com se cargan siempre en la dirección #0100

1.Escribiendo el main.c

Debe de quedar así:


#include 
#include 
void main();

void main() 
{
  __asm //etiqueta de c que indica el cominedo de un bloque con lenguaje ensamblador
    ;imprime Hola MSX claro pio desde com
    ld    c,#9 ; le metemos el 9 en el registro c
    ld    de,#texto ; le metemos el texto en los registros de
    call  #0x0005 ;llamamos a la turina 0005
    ret
texto:    
    .ascii  " Hola MSX claro pio desde com$"
enter:
    .db #0x0d,#0x0a,'$' ;forma utilizada simpre para decirle que ha terminado el string   
  __endasm; //Etiqueta de c que indica el final de un bloque con lenguaje ensamblador
}


2.Creamos una carpeta dsk y metemos los archivos del sistema operativo COMMAND2.COM y MSXDOS2.SYS, pincha aquí para descargar:

3.Creamos el crt0_com:

Ponemos esto en el archivo crt0_com:

.module ctr0
.globl  _main
;no es necesario hacer nada en el area code
.area   _CODE
;no es necesario hacer nada en el area data
.area   _DATA
;no es necesario hacer nada en el area variables a inicializar

.area   _INITIALIZER
;no es necesario hacer nada en el area variables inicializadas
.area   _INITIALIZED
;area cabecera
.area _HEADER (ABS)
    .org    0x100  ;MSX-DOS .COM dirección de inicio
;--- Initialización de las variables globales y salta al main 
.area   _GSINIT
    jp _main
.area   _GSFINAL
    ret



4.Creando el archivo de configuración de openMSX:

Ponemos esto:

machine Philips_NMS_8255 
ext msxdos2 
ext gfx9000 
bind F12 cycle videosource
plug joyporta mouse 
plug printerport simpl 
diska dsk/




5. El make.bat debe quedar así:

@echo off 
Set nombrePrograma=main
Set crt=crt0_com

echo ------------------------------------------
echo     Compilando el programa "%nombrePrograma%"
echo       author: MSX claro pijo 2020
echo ------------------------------------------

rem 1.Pasamos el crt.asm a crt.rel
sdasz80 -l -o %crt%.s

rem 2.compilamos nuestro programa c con el ensamblador embebido
sdcc -mz80 --no-std-crt0 --code-loc 0x100 --data-loc 0x0 %crt%.rel %nombrePrograma%.c 
rem 3. Creamos el binario para MSX con el programa hex2bin
hex2bin -e com %nombrePrograma%.ihx 

rem 4. Movemos el .com a su sitio
move %nombrePrograma%.com ./dsk

rem 5.Despues de crear el archivo emul_start_config.txt abrimos el openMSX
rem en los archivos .bat se crean las constantes con set
rem Esta es mi ruta donde tengo mi openMSX, si lo has instalado lo tendrás en C:\Program Files\openMSX\openmsx.exe
Set rutaOpenMSX=C:\Users\Casa\Desktop\openmsx-0.15.0-windows-vc-x64-bin\openmsx.exe
Set rutaScriptOpenMSX=openMSX\emul_start_config.txt
Set procesoOpenMSX=openmsx.exe
rem tasklist muestra una lista de procesos que se está ejecutando en el equipo, por favor pon tasklist /? en el cmd
rem find busca una cadena ed texto en uno o más archivos, por favor pon find /? en el cmd
tasklist | find /i "%procesoOpenMSX%">nul  && (echo %procesoOpenMSX% openMSX ya esta arrancado) || start %rutaOpenMSX% -script %rutaScriptOpenMSX% 

rem 6.creando una carpeta para mover nuestros recursos
If not exist .\resources md .\resources
rem le ponemos el nombre a nuestro programa

rem lo movemos a resources, por favor pon move /? o @move /? en el cmd
move %nombrePrograma%.asm ./resources
move %nombrePrograma%.bin ./resources
move %nombrePrograma%.ihx ./resources
move %nombrePrograma%.lk ./resources
move %nombrePrograma%.lst ./resources
move %nombrePrograma%.map ./resources
move %nombrePrograma%.noi ./resources
move %nombrePrograma%.rel ./resources
move %nombrePrograma%.sym ./resources



6.Ponemos make.bat y escribimos main.com

8.3.3 Decirle al z80 que disposición de memoria tiene

Por favor mira este video si lo quieres comprender bien “https://www.youtube.com/watch?v=cSnQpclrGDw&feature=emb_logo”.

Los slots se inventaron para aumentar las capacidades de acceso a las posiciones de la memoria RAM ya que el z80 solo puede ver 64kb de memoria RAM.

Al arrancar el MSX lo primero que lee el z80 a través de las rutinas de la bios es la configuración de los slots, es decir los cartuchos y discos si están pinchados le dicen al z80 que disposición de slots tiene que ver, esta es la disposición normal si no se le meten cartuchos o discos:

Se le manda a través del puerto A8 los bytes para poder ver esta configuración.

Cuando conectamos un cartucho, la bios chequea los slots y cuando ve algo en el slot 1 es porque se ha pinchado un cartucho en el external slot 1, entonces la bios configura el puerto A8 para decirle al z80 que vea esto:

Cuando metemos un cartucho de 32 kb, tenemos que decirle al z80 que a través del puerto A8 esto:

Para los megaroms, fm-pac, flash o disk-rom,e sto se soluciona con los subslots.

Nuestro hola mundo ha funcionado porque ha detectado algo en el slot 1 (ya que le hemos metido una rom), pero si la rom tiene más de 16kb entonces no podrá acceder a las posiciones de memoria de 0x8000 a 0xBfff

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *