ZX-Uno - kit de programación modo Radastaniano

[na_th_an]

(perdón por el off-topic)

La verdad es que sí que recuerdo que entre mi círculo de amigos de la facultad la asignatura era un hueso. Sin embargo, mi compañero de piso Phobeous (con quien hice Phantomas Uprising) y yo, que veníamos de frikear bien en nuestros años mozos con los 8 bits (él en CPC, yo en Spectrum) la disfrutamos bastante porque por aquellos entonces nos flipaban las demos de MSDOS y hacíamos nuestros pinitos con los plasmas y los rotozoomers e intentábamos meternos de cabeza a hacerlos en ensamblador. Nos gustaban las cosas a bajo nivel y la asignatura le daba bastante caña al ensamblador. Además, las prácticas de microcontroladores nos parecían muy interesantes.

Al final terminamos la asignatura con un sobresaliente y nos hartamos de trastear... Pero entiendo que para un alumno que llegue a la carrera sin saber qué es un número hexadecimal le resulte dura.

[Haplo]

Sí, si ya digo que leí lo que había sobre el tema y lo busqué en los foros, pero se conoce que soy más torpe de lo que pensaba y no funciona como pienso yo que tiene que hacerlo. Así que nada, esta noche si puedo voy a ver si me aclaro haciendo un programita que me revele la organización de la pila y los registros cuando se llama a una function, sub, sea fastcall o no. (si alguien se atreve le estaría agradecido )

Por cierto, no sé si es porque me acabo de registrar en el foro de boriel, pero los mensajes que envío no se muestran, me aparecen como "pendientes de aprobación" desde hace días, así que poca ayuda puedo pedir allí.

[na_th_an]

Lo tienes, más o menos, en mi post, pero es algo así, por ejemplo:

Código: Seleccionar todo

Sub prueba (uByte x, uByte y, uByte color)
    Asm
        ld a, (ix + 5)    ; x
        ld b, (ix + 7)    ; y
        ld c, (ix + 9)    ; color
    End Asm
End Sub

O, por ejemplo:

Código: Seleccionar todo

Sub prueba2 (uByte a, uInteger b)
    Asm
        ld b, (ix + 5) ; a
        ld l, (ix + 6)
        ld h, (ix + 7) ; b (LSB, MSB)
    End Asm
End Sub

Funciona así, para el parámetro "iésimo" (con i = 1, 2, 3...)

- Si es de 8 bits (uByte, Byte), está en (ix + 3 + 2 * i)
- Si es de 16 bits (uInteger, Integer), el LSB está en (ix + 2 + 2 * i) y el MSB en (ix + 3 + 2 * i)

O, más sencillo:

Código: Seleccionar todo

Sub Fastcall prueba3 (uByte p1, uByte p2, uByte p3)
Asm
    ; p1 está en el registro "A" porque ponemos "Fastcall"
    ; Ahora, en orden:
    pop bc   ; dirección de retorno
    pop hl    ; parámetro p2
    pop de   ; parámetro p3
    push bc  ; hay que poner la dirección de retorno de nuevo en la pila

End Asm
End Sub

O bien

Código: Seleccionar todo

Sub Fastcall prueba3 (uInteger p1, uByte p2)
Asm
    ; p1 está en el registro "HL" porque ponemos "Fastcall" y p1 es de 16 bits
    ; Ahora, en orden:
    pop bc   ; dirección de retorno
    pop de   ; parámetro p2
    push bc  ; hay que poner la dirección de retorno de nuevo en la pila

End Asm
End Sub

Asín es, no tiene mucho más.

[Haplo]

Gracias na_th_an! Lo probaré esta noche.

[antoniovillena]

Exacto. Yo tengo algunos ejemplos en FASE. Lo mejor es hacer todas las funciones FASTCALL, ya que si sólo tienen un parámetro no tienes que manipular la pila, y si tienen más de uno te ahorras un POP. Te pongo un par de funciones del engine por si te valen, pero con lo que te ha explicado na_th_an es suficiente:

Código: Seleccionar todo

sub FASTCALL pausa( time as uinteger )
  asm
loop1:  ld      bc, 21
loop2:  djnz    loop2
        dec     c
        jr      nz, loop2
        dec     hl
        ld      a, l
        or      h
        jr      nz, loop1
  end asm
end sub


Código: Seleccionar todo

sub FASTCALL PrintStr( source as uinteger, xy as uinteger )
  asm
        pop     af
        pop     de
        push    af
        push    hl
        pop     ix
        ld      hl, ($5c00)
print:  ld      a, e
        and     $18
        or      $40
        or      h
        ld      h, a
        ld      a, e
        rrca
        rrca
        rrca
        and     $e0
        add     a, d
        ld      l, a
print1: ex      de, hl
        ld      a, (ix+0)
        inc     ix
        add     a, a
        ret     z
        ld      l, a
        ld      h, $0f
        add     hl, hl
        add     hl, hl
        ld      b, 4
print2: ld      a, (hl)
        ld      (de), a
        inc     l
        inc     d
        ld      a, (hl)
        ld      (de), a
        inc     l
        inc     d
        djnz    print2
        ld      hl, $f801
        add     hl, de
        jr      print1
  end asm
end sub


Por cierto el ret del final no lo pongas nunca, lo hace el compilador automáticamente.

[Haplo]

Me he tenido que pelear de lo lindo con varias cosillas aparte de los push, pop y non stop pero al final funciona:

radok.JPG (35.83 KiB) Visto 7430 veces

Mañana limpiaré el guarreo de código que tengo de hacer pruebas y lo subo para que le echéis un ojito.
A dormir!

[radastan]

¡Oleeeeeee!

Pues no olvides poner las rutinas definitivas en otro hilo al efecto, uno que se llame "Kit ZX Basic para ZX Uno" o similar. Hay que promocionar esto para que empiece a coger carrerilla.

A mi me han puteado esta semana y estoy de sol a sol modificando el funcionamiento de una planta de biocombustible, una putada porque ya tengo todo lo necesario para hacer algún juego chorra. A ver si mañana, que tengo el día libre, puedo sentarme y hacer aunque sea un mojoncillo para los que van a Retromadrid Days dentro de una semana.

[na_th_an]

¿Qué emuladores que funcionen en Windows soportan esto? ¿Los de A. Villena, por ejemplo?

[mcleod_ideafix]

Yo estoy intentando portar a Windows el ZEsaurUX de César, que tiene soporte de ULAplus y modo Radastaniano

[Haplo]

Yo estoy intentando portar a Windows el ZEsaurUX de César, que tiene soporte de ULAplus y modo Radastaniano

Ufff, si lo consigues tienes una cerveza tamaño familiar pagada en Retromadrid!
No te imaginas cómo tengo el dedo de sacar/meter la SD entre el portátil y el ZXuno para hacer pruebas...