Karoshi MSX Community
26 de Mayo de 2017, 07:55:04 am *
Bienvenido(a), Visitante. Por favor, ingresa o regístrate.

Ingresar con nombre de usuario, contraseña y duración de la sesión
Noticias:
 
   Inicio   Ayuda Buscar Calendario Ingresar Registrarse  
Páginas: 1 [2]
  Imprimir  
Autor Tema: Ayuda para Modificar Programa  (Leído 6799 veces)
0 Usuarios y 1 Visitante están viendo este tema.
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #15 : 03 de Julio de 2014, 02:01:34 am »

Hola:

Estos días he estado mirando un poco tu Programa Ensamblador, PhSoft y tratando de entenderlo. Más o menos entiendo, o intuyo, lo que haces aunque bueno mis conocimientos de Ensamblador son muy muy MUY LIMITADOS. :-(

"Googleando" también encontré un Documento sobre el Cassette en el MSX. El documento en cuestión está aquí: http://www.msxarchive.nl/pub/msx/docs/hardware/msx-tape.doc

Como creo que puede resultar de interés hago un "Ana Rosa Quintana" (copy & paste) aquí:

Código:
MSX Tape I/O
-------------

BIT AND BYTE ENCODING

Information on tape is stored as square waves of 1200 or 2400 baud. The
encoding used is FSK (frequency shifting key). The next table shows the
relation between the selected recording speed, the bits and the pulses
put on tape:

bps   bit   encoding          freq (Hz)
                    _______
1200   0    _______|       |  1200
                ___     ___
1200   1    ___|   |___|   |  2400

                ___
2400   0    ___|   |          2400
              _   _
2400   1    _| |_| |          4800

Each byte is put on tape as a sequence of 11 bits:

 0 b0 b1 b2 b3 b4 b5 b6 b7 1 1  (one startbit, 2 stopbits, LSb first)

Futhermore 2 kinds of headers are used: short and long, a long header being
4 times as long as a short one. They consist of a series of square wave pulses
(bit value 1):

bps   header   freq (Hz)   nr of pulses
1200  short    2400        4000             (5/3  sec)
1200  long     2400        16000            (20/3 sec)
2400  short    4800        8000
2400  long     4800        32000


FILE FORMATS

Files on tape are stored in two blocks. The first block is the filedescriptor,
the second contains the filedata.  Three types of files exist:
BASIC file, memory dump and data file.

BASIC File (CSAVE/CLOAD)
  filedescriptor: long header
                  10x #D3       (filetype)
                  6 bytes filename

  file data:      short header
                  tokenized BASIC
                  7x #00

memory dump (BSAVE/BLOAD)
  filedescriptor: long header
                  10x #D0
                  6 bytes filename

  file data:      short header
                  2 bytes start address
                  2 bytes end address
                  2 bytes exec address
                  memory dump

data file (SAVE/LOAD/OPEN)
  filedescriptor: long header
                  10x #EA
                  6 bytes filename

  file data:      short header
                  block of 256 bytes

                  short header
                  block of 256 bytes

                  ....
                  last block contains 256x #1A (^Z/EoF)


Así pues tenemos que en MSX hay 3 tipos de Carga/Grabación desde/en Cassette:

-CLOAD/CSAVE.
-LOAD/SAVE.
-BLOAD/BSAVE.


Hay 2 velocidades diferentes para grabar nuestros Programas:

- 1200 baudios.
- 2400 baudios.


Cada Byte se graba siempre añadiendo un bit por la Izquierda (un 0) que indica el comienzo, luego iría el Byte propiamente dicho, y al final se añaden dos bits (dos CEROS) que indican el final del Byte.


Los Ficheros-Programas para grabarse en Cinta se graban en 2 Bloques:

- Un primer Bloque (Descriptor de Fichero) que nos indica el tipo de Fichero.
- Un segundo Bloque que contiene los Datos propiamente dichos.


Cada Tipo de Fichero (CLOAD, LOAD, BLOAD) tiene sus peculiaridades:


1. Ficheros CLOAD --> (BASIC)

   ■ Descriptor de Fichero, formado por:
         -Cabecera Larga.
         -10 bytes con el valor "D3"  (el valor "D3" nos indica que es un Fichero CLOAD)
         -6 bytes  que contienen el nombre del Fichero.

   ■ Datos propiamente dichos del Fichero, formados por:      
         -Cabecera Corta
         -Caracteres del Programa BASIC "Tokenizados"
         -7 bytes  con el valor "00" que indican el final del Fichero.


2.Ficheros LOAD/OPEN  --> (ASCII)

   ■ Descriptor de Fichero, formado por:
         -Cabecera Larga
         -10 bytes con el valor "EA" (ese valor "EA" nos indica que es un fichero de tipo LOAD/OPEN)
         -6 bytes con el nombre del Fichero.

   ■ Datos propiamente dichos del Fichero, formados por:      
         -Cabecera Corta.
         -Bloque  de 256 bytes

         -Cabecera Corta.
         -Bloque  de 256 bytes

         -Cabecera Corta.
         -Bloque  de 256 bytes

            ..........................  
            ..........................
         -Cabecera Corta.
         -Un último Bloque que contiene 256 bytes con el valor "1A" (ese valor "1A" indica el final del Fichero)


3.Ficheros BLOAD --> Código Máquina:

   ■ Descriptor de Fichero, formado por:  
            -Cabecera Larga.
            -10 bytes que contienen el valor "D0" (este valor "D0" nos indica que es un Fichero de Tipo BLOAD)
            -6 bytes con el nombre del Fichero.

   ■ Datos propiamentes dichos del Fichero, formados por:
            -2 bytes, que contienen la Dirección de Inicio.
            -2 bytes, que contienen la Dirección Final.
            -2 bytes, que contienen la Dirección de Ejecución.
            -El Volcado de los Datos del Programa que están en memoria.




-La Instrucción TAPION (Dir. &H00E1), hace un "Motor On" y lee una Cabecera del Cassette (tanto larga como corta).
-La Instrucción TAPIN (Dir. &H00E4), lee solamente un Byte del Cassette.
-La Instrucción TAPIOF (Dir. &H00E7), pone fin a la Lectura desde el Cassette.



Preguntas que me surgen...

1. ¿La Instrucción "TAPION" lee CABECERAS tanto largas como cortas, ¿verdad?

2. Cuando se comienza a leer un Programa al principio hay un Bit/Byte que indica el tipo de velocidad: 1200 ó 2400 Baudos. El tipo de Velocidad lo obtenemos de la Cabecera Larga, ¿verdad? La velocidad con la que ha sido grabado el Programa entiendo que viene al Principio y es un Dato que siempre está presente para todos los Tipos de Fichero: CLOAD/LOAD/BLOAD, ¿cierto?

3. ¿Cuál es la Estructura de esa Cabecera Larga?

4. En los Ficheros de Tipo LOAD entiendo que cada Bloque de 256Bytes está precedido por una Cabecera Corta, ¿cierto?

5. Cuando leemos las Direcciones de Inicio/Fin/Ejecución en los Ficheros "BLOAD" se interprenta al revés, ¿verdad? Es decir si al leer de la Cinta primero tenemos "00" y luego "1A" la dirección sería "1A00", ¿correcto?

Gracias & Saludetes. ;-)
« Última modificación: 08 de Febrero de 2015, 05:26:52 am por manolito74 » En línea
mohai
Karoshi Fan
**
Mensajes: 78



Ver Perfil
« Respuesta #16 : 17 de Septiembre de 2014, 09:41:54 am »

1. ¿La Instrucción "TAPION" lee CABECERAS tanto largas como cortas, ¿verdad?

Correcto.
Al leer la cabecera o pitido inicial, lo que hace es leer un poquito de la cabecera y ajustar las variables del sistema para la velocidad detectada.
Puedes hacer la prueba con una cinta, verás como esta rutina apenas lee un segundo de la cinta.

2. Cuando se comienza a leer un Programa al principio hay un Bit/Byte que indica el tipo de velocidad: 1200 ó 2400 Baudos. El tipo de Velocidad lo obtenemos de la Cabecera Larga, ¿verdad? La velocidad con la que ha sido grabado el Programa entiendo que viene al Principio y es un Dato que siempre está presente para todos los Tipos de Fichero: CLOAD/LOAD/BLOAD, ¿cierto?

La deteccion de velocidad la hace la lectura de la cabecera, por la frecuencia que esa rutina detecta.
Por lo que yo sé, se hacen 2 ajustes de velocidad, uno con la cabecera larga y otro con la corta.
El BIOS, en realidad, al ajustarse a la velocidad de la grabación, es capaz de leer a otras velocidades diferentes a las que ofrece el BASIC.
Un experimento interesante, consiste en tocar las variables del sistema para grabar a velocidades diferentes de 1200 o 2400.
Yo he conseguido grabar a 1000 o 600 baudios y leerlo sin problema.

No hay ningún bit ni byte que le diga al MSX la velocidad a cargar.
La información que has puesto antes, es lo que hay. Ni más ni menos.

3. ¿Cuál es la Estructura de esa Cabecera Larga?

La estructura no es más que una onda pura.

4. En los Ficheros de Tipo LOAD entiendo que cada Bloque de 256Bytes está precedido por una Cabecera Corta, ¿cierto?

Correcto. Haz un programa de más 256 bytes, luego SAVE¨CAS:" y mira lo que hace.
Por cierto, en el formato LOAD, lo que se graba es tipo ASCII, o sea, texto puro y duro.

5. Cuando leemos las Direcciones de Inicio/Fin/Ejecución en los Ficheros "BLOAD" se interprenta al revés, ¿verdad? Es decir si al leer de la Cinta primero tenemos "00" y luego "1A" la dirección sería "1A00", ¿correcto?

Correcto. Esto es porque es un valor de 16 bits y el Z80 lo almacena así en memoria.
En línea
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #17 : 08 de Febrero de 2015, 08:10:07 am »

Hola de nuevo:

Revisando el código dices que con los Bloques ASCII te da problemas. No sé, quizás a mí me parezca muy obvio o quizás sea una chorrada lo que voy a decir pero... en la última insturcción del bloque que te pongo, ¿no deberías hacer LD B, 255?

Citar
bld1:         push   hl            
         call   TAPION
         pop   hl
         jp   c, EXIT

         ld   b, 0            ; carga bloques de 256 bytes   


Por cierto, una pregunta chorra pero que no tengo clara. En los Ficheros de tipo "LOAD", el último Bloque está formado también por 256 bytes pero ¿ese último Bloque está formado por 256 bytes que contienen todos ellos el valor "1A" o hay 255 bytes de datos y el byte 256 es el que contiene el valor "1A"?

Gracias & Saludetes. ;-)
En línea
e_sedes
Karoshi Maniac
****
Mensajes: 442



Ver Perfil Email
« Respuesta #18 : 09 de Febrero de 2015, 02:07:31 am »

Revisando el código dices que con los Bloques ASCII te da problemas. No sé, quizás a mí me parezca muy obvio o quizás sea una chorrada lo que voy a decir pero... en la última insturcción del bloque que te pongo, ¿no deberías hacer LD B, 255?
DJNZ primero decrementa B y luego mira si llegó a 0. Si lo pones a 0 al principio, en la primera pasada lo decrementa y lo pone a 255. Así consigues que el bucle pase 256 veces. Si cargas B con 255 solo haces 255 pasadas. No se si me explico  Tongue
En línea

sempre fun un valente corredor
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #19 : 09 de Febrero de 2015, 02:34:53 am »

Hola:

Ok @e_sedes, ¡entendido! Ya me parecía a mí que sería un error muy evidente. XD

Entonces, ¿dónde podría estar el error que comenta su autor, @Phsoft, en lo que refiere a los Bloques LOAD?

Más cosas... ¿Qué hace la instrucción "EXX"?, ¿y "STMOTR?

Respecto a lo de Grabar los Ficheros en Disco por lo que me han comentado el manejo de las Rutinas de Disco en Ensamblador puro y duro es pelín complejo, así que lo más fácil sería ejecutar desde el Programa el comando Basic "BSAVE". Sé que la dirección de la Instrucción BSAVE es la &H39CC.

Intenté hacer una prueba con un "simple objetivo": quiero grabar el Código que hay en Memoria a partir de la Dirección inicial &HC00 y con Dirección Final &HC119 y darle como nombre al Programa en Disco "PATATA.BIN".

He hecho un amago de Programa directamente en el MSX, en el "RSC-2". El caso es que en la línea 120 tendría que cargar el texto a ejecutar, pero que no sé como ponerlo (lo he puesto así para que se entienda) Además hay que tener en cuenta que habría que meterle también la pulsación de la tecla "INTRO" :-(

Otra pregunta chorra... (y que nadie se ría...) Vale, sé que el código de este Programa va a empezar en &HC000 pero... ¿cómo sé dónde acaba? O dicho de otra forma, ¿cómo sé la dirección final para grabar el Binario resultante de mi Ejemplo ASM?

Nota: estoy usando el RSC-2.

Gracias & Saludetes. ;-(

Pd. ¿Qué Ensamblador y Desensamblador me recomendaiss para usar en PC? ¿Alguien usa algún otro aparte del AsMSX?

Código:
10 ORG &HC000
20 ;
30 INS:    DEFM "BSAVE"
40 NOM:   DEFM¨PATATA.BIN"
50 INI:     DEFM "&HC000"
60 FIN:     DEFM "&HC119"
70 ;
80 TECLA:         EQU &H9F
90 INTRO:         EQU &H00
100 SAVEDISK:  EQU &H39CC
110 ;
120 LD HL,
130 LD IX, SAVEDISK
140 ;
150 CALL SAVEDISK
160 CALL TECLA
170 RET


En línea
e_sedes
Karoshi Maniac
****
Mensajes: 442



Ver Perfil Email
« Respuesta #20 : 10 de Febrero de 2015, 12:47:56 am »

Esto nunca lo había mirado, pero le he echado un ojo al MSXTopSecret2 donde explica esto y veo un par de cositas (recomiendo muchísimo este documento).

HL tiene que apuntar a una línea de BASIC con los argumentos del comando que quieras utilizar. Puedes escribir la linea en un emulador y luego usar el debugger para ver como se guarda en memoria. Tiene que acabar con &h00.

IX tiene que apuntar al comando que quieras usar. Ojo, BSAVE no está en &h39CC, como dices. Esa es una posición en una tabla que contiene la dirección de BSAVE. Deberías leer ahí la dirección, pero por lo visto en todos los modelos de MSX es siempre la misma, no la cambiaron nunca. La verdadera dirección es  &h6E92.

Despues tienes que llamar a la rutina CALBAS (&h0159), que es la que llama al comando.

En teoría así te debería funcionar, yo no lo he probado. Tambien tienes que tener en cuenta que si hay algún error te saltaría al BASIC, por lo que tendrías que interceptar el gancho HERRO (&hFFB1) para que eso no te pasase.


En línea

sempre fun un valente corredor
Metalbrain
Karoshi Fan
**
Mensajes: 92


Z80jutsushi


Ver Perfil
« Respuesta #21 : 11 de Febrero de 2015, 12:22:11 pm »

Más cosas... ¿Qué hace la instrucción "EXX"?,

En el Z80, los principales registros tienen un duplicado, que se distingue del original con un apóstrofe. Así, tenemos los registros alternativos AF', BC', DE' y HL'.

Estos registros no son accesibles directamente, pero mediante la instrucción "EXX" se intercambian los valores entre los principales y los alternativos en el caso de BC, DE y HL. Y con la instrucción "EX AF, AF'", se intercambia el que faltaba.

En la práctica es como tener un juego alternativo de registros y puedes intercambiar entre uno y otro. El intercambio entre un juego y otro (en realidad entre sus valores, pero vamos, en la práctica es lo mismo), es mucho más rápido que usar variables en memoria o la pila cuando te quedas sin registros.
En línea
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #22 : 16 de Febrero de 2015, 07:04:24 pm »

Hola de nuevo:

Cierto @e_sedes. Lo expliqué mal. La dirección que puse no es la de BSAVE sino que se usa para obtener la dirección real de BSAVE. Estuve haciendo pruebas pero lo dejé por imposible ya que no fui capaz de que funcionara. :-(

Gracias por la info @Metalbrain. Totalmente aclarado el tema de EXX. ;-)

Saludetes. ;-)
En línea
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #23 : 14 de Octubre de 2015, 03:08:48 am »

Hola:

Por causalidad he llegado hasta este Hilo:

http://www.zonadepruebas.org/backup/modules/newbb/viewtopic.php?topic_id=10152&forum=2&start=30

Y resulta curioso-útil lo que aquí comentan:

Citar
...............
Un sistema parecido lo utilicé para hacerme un copión de cinta a disco en ensamblador del Z80...... Cargaba el programa, y al ejecutarse desconectaba el BASIC, con lo que tenía 64KB de RAM. y leía un bloque de la cinta, que luego volcaba a un fichero en disco. La verdad es que funcionaba. A veces un poco lioso porque había que desconectar bloques de RAM, para acceder a la BIOS, pero bueno... Me faltaba hacer unos los menús bonitos....
................

Interesante técnica para tener toda la Ram Libre. ;-)

Una pregunta, quizás trivial para algunos pero desconocida para mí. Un MSX-1 POR DEFECTO tiene 64 Kb de RAM. Si tenemos una Disquetera, ¿esa disquetera resta Memoria Ram o solo nos quita Memoria Ram cuando tenemos una Segunda Disquetera?

Gracias & Saludetes. ;-)
En línea
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #24 : 18 de Octubre de 2015, 01:16:31 pm »

Hola:

Bueno, pues como soy un poco "cabezota" he seguido haciendo pruebas con lo de ejecutar instrucciones BASIC desde un Programa en Ensamblador.

En este caso en concreto quería ejecutar la Instrucción BSAVE. Quería grabar la zona de Memoria comprendida entre las &HC00 y &HC119 y darle como nombre al Fichero en Disco "PATATA.BIN".

El "complejo" Código sería este:

Código:
RSC II MSX 1.0                                                

   10 ORG  &HC000
   20 BSAVEDSK: EQU  &H39CC
   30 CHGET: EQU  &H9F
   40 CALBAS: EQU  &H159
   50 LD   HL, LINBAS
   60 LD   IX, (BSAVEDSK)
   70 CALL CALBAS
   80 CALL CHGET
   90 RET
  100 LINBAS: DEFB &H22
  110 DEFM "PATATA.BIN"
  120 DEFB &H22
  130 DEFM ",&HC000"
  140 DEFM ",&HC119"
  150 DEFB &H00
  160 FIN: NOP

El Programa está hecho usando el RSC II.

- En la Línea 20 tenemos la Dirección de la Instrucción BSAVE.
- La línea 30 tiene como finalidad que pulsemos una Tecla.
- La línea 40 nos servirá para ejecutar la Instrucción BSAVE.
- En la línea 50 hacemos que HL apunte a una falsa línea en Basic (LINBAS)
- En la línea 60 cargamos la dirección de la Rutina BSAVE.
- En la línea 70 ejecutamos la instrucción BSAVE.
- En la línea 80 esperamos a que se pulse una Tecla.
- En la línea 100 y posteriores definimos nuestra línea Basic "virtual" en la lo que hacemos simplemente es definir todos los argumentos-parámetros necesarios para completar la Instrucción BSAVE (lo que pongo abajo en rojo)

BSAVE"PATATA.BIN", &HC000, &HC119

Pues bien, yo con lo que me liaba, entre otras cosas era en la definición de todo eso que pongo en rojo. No sabía como poner las comillas usando la instrucción DEFM, ya que no sería posible hacer esto: DEFM ""PATATA.BIN"" así que lo tendremos que hacer por partes, es decir:

- En la línea 100 lo que hacemos es definir las "comillas" (&H22)
- En la línea 110 el nombre del Fichero (PATATA.BIN)
- En la línea 120 otra vez las comillas (&H22)
- En la línea 130 definimos la coma y la dirección inicial, es decir ,&HC000
- En la línea 140 definimos la coma y la dirección final, es decir ,&HC119
- Muy importante en la línea 150 hacemos que nuestra instrucción acabe con &H00.

La verdad es que se me antoja una opción muy potente el usar este método para ejecutar comandos y funciones BASIC desde nuestros programas en Ensamblador.

Toda esta Info viene recogida en el Libro-Manual "MSX TOP SECRET", en concreto en el Tema 2 páginas 36 a 39.  ¡¡¡1.000 gracias a su autor por toda esta Info!!!

Saludetes. ;-)



« Última modificación: 12 de Diciembre de 2016, 02:01:27 am por manolito74 » En línea
manolito74
Karoshi Lover
***
Mensajes: 234


Ver Perfil
« Respuesta #25 : 14 de Diciembre de 2016, 02:57:01 am »

Hola de nuevo:

He estado revisando el Programa:

Código:
CSAVE_FILE equ 0xD3 ; eof = n data hasta 7bytes 0x0
SAVE_FILE equ 0xEA ; eof = n bloques 256 bytes hasta CTRL+Z
BSAVE_FILE equ 0xD0

INI_BASIC equ 0x8001 ; lol!
INI_PRG equ 0xF000

; --------------------------------------
.bios
.basic
.org INI_PRG
.start MAIN

MAIN: di

xor a ; limpiando la casa
ld hl, iniram
ld bc, endram-iniram-1
call CLSRAM

call LHEADER ; leemos una cabecera

ret

; --------------------------------------
; inicia o detiene el motor del cassette
MOTORON: ld a, 1
bmotor: call STMOTR      
ret
MOTOROFF: xor a
jr bmotor

; --------------------------------------
; salimos (por error de lectura) o paramos el cassete
EXIT: pop hl
STOP: call TAPIOF      
ret

; --------------------------------------
; leemos datos (un byte) del cassete; C si se produce un error
READ: exx              
call TAPIN    
jr c, EXIT
exx              
ret              

; --------------------------------------
; leemos la cabecera larga del cassete; tipo = 10 bytes + nombre = 6 bytes
LHEADER: call TAPION
jr c, EXIT

ld b, 10 ; 10 bytes
ld hl, tipo_fichero
bucH: call READ  
ld [hl], a
djnz bucH

ld b, 6 ; 6 bytes
ld hl, nom_fichero
bucN: call READ
ld [hl], a
inc hl
djnz bucN

call STOP

ld a, [tipo_fichero] ; tipo de fichero

cp BSAVE_FILE
jp z, BLOAD ; cargamos binario

cp SAVE_FILE
jp z, LOAD ; cargamos basic SAVE

cp CSAVE_FILE
jp z, CLOAD ; cargamos basic CSAVE

; TODO: fichero desconocido

; TODO: presentar informacion
; TODO: grabar fichero a disco

ret

; --------------------------------------
; cload tiene una cabecera corta que leemos con TAPION y luego
; los datos hasta encontrar 7 ceros seguidos
CLOAD: call rstzeros
xor a
ld [INI_BASIC-1], a ; 0 en 0x8000; requerido

ld hl, INI_BASIC
push hl
call TAPION
pop hl
jr c, EXIT

bcld: call READ
ld [hl], a
inc hl
cp 0
call nz, rstzeros
call z, inczeros
ld a, [temp1]
cp 7 ; termina con 7 ceros
jr nz, bcld

jr STOP

rstzeros: xor a
ld [temp1], a
ret

inczeros: ld a, [temp1]
inc a
ld [temp1], a
ret

; --------------------------------------
; load contiene multiples bloques de 256 bytes hasta 0x1a (ctrl+z)
; cada bloque tiene su cabecera corta que leemos con TAPION
LOAD: xor a
ld [INI_BASIC-1], a ; 0 en 0x8000; requerido

ld hl, INI_BASIC

bld1: push hl
call TAPION
pop hl
jp c, EXIT

ld b, 0 ; carga bloques de 256 bytes
bld2: call READ
cp 0x1a ; ctrl + z
jp z, STOP
ld [hl], a
inc hl
djnz bld2 ; fin de bloque

push hl
call TAPIOF
pop hl
jr bld1

; --------------------------------------
; bload tiene una cabecera corta seguida de 6 bytes con
; las direcciones de inicio, fin y ejecución del programa
; a continuación va el bloque de datos, todo seguido
BLOAD: xor a
ld hl, inifile
ld bc, finfile-inifile-1
call CLSRAM ; borra dirs fichero

call TAPION
jp c, EXIT

ld b, 6 ; 6 bytes
ld hl, inifile
bblh: call READ
ld [hl], a
inc hl
djnz bblh

call MOTOROFF
call calclng ; calculamos longitud
push hl
call MOTORON
pop bc ; longitud
ld hl,INI_BASIC ; inicio (temporal)

bbld: call READ
ld [hl], a
inc hl
dec bc
ld a, b
or c
jr nz, bbld

jp STOP

calclng: ld ix,inifile
ld e, [ix+0]
ld d, [ix+1] ; de = ini (real)
ld l, [ix+2]
ld h, [ix+3] ; hl = fin (real)
sbc hl, de ; longitud = fin - ini
ret

; -------------------------------------
; rellenamos bc+1 bytes de ram con el valor de A
CLSRAM: ld [hl], a
ld d, h
ld e, l
inc de
ldir
ret

; --------------------------------------
iniram: defb 0

tipo_fichero: defs 1
nom_fichero: defs 6

inifile: defs 2
finfile: defs 2
exefile: defs 2

temp1: defs 1

endram: defb 0


Si no me equivoco @PhSoft tú comentabas que el problema estriba en que con los Programas de tipo "LOAD/SAVE" el Código del Programa no aparece "tokenizado" en la Memoria del Emulador.

Si yo te entiendo bien eso viene a decir que lo que tiene que aparecer a partir de la Dirección &h8000 cuando el Programa lee un Bloque LOAD las instrucciones de dicho Programa tal cual en esa zona de memoria, ¿no?

Si es así comentarte que sí que funciona. Yo como no me aclaro con el Debugger del Open MSX he usado el del MAME que me ha resultado más cómodo e intuitivo (al menos para este propósito) Te pongo aquí la captura:

imag


Por si a alguien le interesa y/o no sabía que con el MAME se puede emular el MSX y además usar un Debugger os pongo aquí cómo hacerlo.



Tutorial Express: MAME - MSX - DEBUGGER:

Nota: yo no sabía que el MAME emulaba al MSX y apenas encontré información sobre cómo hacerlo. :-(

– Descargamos la Rom del MSX que vamos a usar. El MAME emula unos cuantos modelos de MSX y MSX-2. Yo había probado con la ROM del 8245 pero parece que no está bien o hay algún problema así que probé con la del 8250, que os podéis descargar desde aquí:

 http://www.planetemu.net/rom/mame-roms/nms8250-1  (y pulsamos en “Telecharger”)

Descargamos dicha ROM y la copiamos sin descomprimir en la Carpeta "ROMS" del MAME.

– Ahora abrimos una consola de MS-DOS (es decir, ejecutamos un CMD) y escribimos lo siguiente:

mame64  nms8250 -windows -debug

Con esto ejecutamos el MAME y se lanza su Debugger. Desde el Debugger en el apartado "Images" podemos elegir cómodamente el Disco y/o Cinta que queremos cargar.

Yo cargo una imagen de Disquete con el Binario de tu Programa en ASM y una CINTA. Para ejecutar el MAME desde el Debugger lo hacemos con "F5". Luego ya dentro del MAME cuando ha cargado el BASIC ejecuto tu Programa desde el propio BASIC y en el Debugger hago un "New Memory Window" (para ver el contenido de la Memoria en una ventana aparte). Me voy a la dirección de memoria 8000....y allí veo el listado tokenizado del Programa BASIC. Así que si te referías a eso comentarte que sí que rula tu Programa. ;-)

Y la prueba del delito es la imagen que puse más arriba. ;-)

Ahora como siguiente pequeño paso a abarcar pues sería ir mostrando la info del Bloque que encuentra en la Cinta (nombre, tipo de bloque, dirección de inicio-fin-ejecución, etc)

Luego una vez pulido esa pequeña labor habría que ver ya cómo gestionar la grabación de los Bloques que vamos cargando en Disco. Se me ocurre que la forma más rápida-cómoda (que no sé si la mejor) podría ser ejecutando directamente desde el Programa ".ASM" la instrucción Basic correspondiente (SAVE, BSAVE, CSAVE) a la cual le habría que pasar los parámetros correspondientes. ;-)

Saludetes. ;-)
« Última modificación: 14 de Diciembre de 2016, 03:01:22 am por manolito74 » En línea
Páginas: 1 [2]
  Imprimir  
 
Ir a:  

Impulsado por MySQL Impulsado por PHP Powered by SMF 1.1.21 | SMF © 2013, Simple Machines XHTML 1.0 válido! CSS válido!